zrb 1.15.3__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/task/llm/conversation_history_model.py

@@ -1,242 +0,0 @@
-import json
-import os
-from collections.abc import Callable
-from typing import Any
-
-from zrb.config.llm_context.config import llm_context_config
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.typing import ListOfDict
-from zrb.util.file import read_file
-from zrb.util.llm.prompt import make_prompt_section
-from zrb.util.run import run_async
-
-
-class ConversationHistory:
-
-    def __init__(
-        self,
-        past_conversation_summary: str = "",
-        past_conversation_transcript: str = "",
-        history: ListOfDict | None = None,
-        contextual_note: str | None = None,
-        long_term_note: str | None = None,
-        project_path: str | None = None,
-    ):
-        self.past_conversation_transcript = past_conversation_transcript
-        self.past_conversation_summary = past_conversation_summary
-        self.history = history if history is not None else []
-        self.contextual_note = contextual_note if contextual_note is not None else ""
-        self.long_term_note = long_term_note if long_term_note is not None else ""
-        self.project_path = project_path if project_path is not None else os.getcwd()
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "past_conversation_summary": self.past_conversation_summary,
-            "past_conversation_transcript": self.past_conversation_transcript,
-            "history": self.history,
-            "contextual_note": self.contextual_note,
-            "long_term_note": self.long_term_note,
-        }
-
-    def model_dump_json(self, indent: int = 2) -> str:
-        return json.dumps(self.to_dict(), indent=indent)
-
-    @classmethod
-    async def read_from_source(
-        cls,
-        ctx: AnyContext,
-        reader: Callable[[AnyContext], dict[str, Any] | list | None] | None,
-        file_path: str | None,
-    ) -> "ConversationHistory | None":
-        # Priority 1: Reader function
-        if reader:
-            try:
-                raw_data = await run_async(reader(ctx))
-                if raw_data:
-                    instance = cls.parse_and_validate(ctx, raw_data, "reader")
-                    if instance:
-                        return instance
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error executing conversation history reader: {e}. Ignoring."
-                )
-        # Priority 2: History file
-        if file_path and os.path.isfile(file_path):
-            try:
-                content = read_file(file_path)
-                raw_data = json.loads(content)
-                instance = cls.parse_and_validate(ctx, raw_data, f"file '{file_path}'")
-                if instance:
-                    return instance
-            except json.JSONDecodeError:
-                ctx.log_warning(
-                    f"Could not decode JSON from history file '{file_path}'. "
-                    "Ignoring file content."
-                )
-            except Exception as e:
-                ctx.log_warning(
-                    f"Error reading history file '{file_path}': {e}. "
-                    "Ignoring file content."
-                )
-        # Fallback: Return default value
-        return None
-
-    def fetch_newest_notes(self):
-        self._fetch_long_term_note()
-        self._fetch_contextual_note()
-
-    @classmethod
-    def parse_and_validate(
-        cls, ctx: AnyContext, data: Any, source: str
-    ) -> "ConversationHistory":
-        try:
-            if isinstance(data, cls):
-                return data  # Already a valid instance
-            if isinstance(data, dict):
-                # This handles both the new format and the old {'context': ..., 'history': ...}
-                return cls(
-                    past_conversation_summary=data.get("past_conversation_summary", ""),
-                    past_conversation_transcript=data.get(
-                        "past_conversation_transcript", ""
-                    ),
-                    history=data.get("history", data.get("messages", [])),
-                    contextual_note=data.get("contextual_note", ""),
-                    long_term_note=data.get("long_term_note", ""),
-                )
-            elif isinstance(data, list):
-                # Handle very old format (just a list) - wrap it
-                ctx.log_warning(
-                    f"History from {source} contains legacy list format. "
-                    "Wrapping it into the new structure. "
-                    "Consider updating the source format."
-                )
-                return cls(history=data)
-            else:
-                ctx.log_warning(
-                    f"History data from {source} has unexpected format "
-                    f"(type: {type(data)}). Ignoring."
-                )
-        except Exception as e:  # Catch validation errors too
-            ctx.log_warning(
-                f"Error validating/parsing history data from {source}: {e}. Ignoring."
-            )
-        return cls()
-
-    def write_past_conversation_summary(self, past_conversation_summary: str):
-        """
-        Write or update the past conversation summary.
-
-        Use this tool to store or update a summary of previous conversations for
-        future reference. This is useful for providing context to LLMs or other tools
-        that need a concise history.
-
-        Args:
-            past_conversation_summary (str): The summary text to store.
-
-        Returns:
-            str: A JSON object indicating the success or failure of the operation.
-
-        Raises:
-            Exception: If the summary cannot be written.
-        """
-        self.past_conversation_summary = past_conversation_summary
-        return json.dumps({"success": True})
-
-    def write_past_conversation_transcript(self, past_conversation_transcript: str):
-        """
-        Write or update the past conversation transcript.
-
-        Use this tool to store or update the full transcript of previous conversations.
-        This is useful for providing detailed context to LLMs or for record-keeping.
-
-        Args:
-            past_conversation_transcript (str): The transcript text to store.
-
-        Returns:
-            str: A JSON object indicating the success or failure of the operation.
-
-        Raises:
-            Exception: If the transcript cannot be written.
-        """
-        self.past_conversation_transcript = past_conversation_transcript
-        return json.dumps({"success": True})
-
-    def read_long_term_note(self) -> str:
-        """
-        Read the content of the long-term references.
-
-        This tool helps you retrieve knowledge or notes stored for long-term reference.
-        If the note does not exist, you may want to create it using the write tool.
-
-        Returns:
-            str: JSON with content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        return json.dumps({"content": self._fetch_long_term_note()})
-
-    def write_long_term_note(self, content: str) -> str:
-        """
-        Write the entire content of the long-term references.
-        This will overwrite any existing long-term notes.
-
-        Args:
-            content (str): The full content of the long-term notes.
-
-        Returns:
-            str: JSON indicating success.
-        """
-        llm_context_config.write_context(content, context_path="/")
-        return json.dumps({"success": True})
-
-    def read_contextual_note(self) -> str:
-        """
-        Read the content of the contextual references for the current project.
-
-        This tool helps you retrieve knowledge or notes stored for contextual reference.
-        If the note does not exist, you may want to create it using the write tool.
-
-        Returns:
-            str: JSON with content of the notes.
-
-        Raises:
-            Exception: If the note cannot be read.
-        """
-        return json.dumps({"content": self._fetch_contextual_note()})
-
-    def write_contextual_note(
-        self, content: str, context_path: str | None = None
-    ) -> str:
-        """
-        Write the entire content of the contextual references for a specific path.
-        This will overwrite any existing contextual notes for that path.
-
-        Args:
-            content (str): The full content of the contextual notes.
-            context_path (str, optional): The directory path for the context.
-                                        Defaults to the current project path.
-
-        Returns:
-            str: JSON indicating success.
-        """
-        if context_path is None:
-            context_path = self.project_path
-        llm_context_config.write_context(content, context_path=context_path)
-        return json.dumps({"success": True})
-
-    def _fetch_long_term_note(self):
-        contexts = llm_context_config.get_contexts(cwd=self.project_path)
-        self.long_term_note = contexts.get("/", "")
-        return self.long_term_note
-
-    def _fetch_contextual_note(self):
-        contexts = llm_context_config.get_contexts(cwd=self.project_path)
-        self.contextual_note = "\n".join(
-            [
-                make_prompt_section(header, content)
-                for header, content in contexts.items()
-                if header != "/"
-            ]
-        )
-        return self.contextual_note

zrb/task/llm/default_workflow/coding.md

@@ -1,24 +0,0 @@
-When the user's request involves writing or modifying code, you MUST follow these domain-specific rules in addition to your core workflow.
-
-## 1. Critical Prohibitions
-- **NEVER Assume Dependencies:** You MUST NOT use a library, framework, or package unless you have first verified it is an existing project dependency (e.g., in `package.json`, `requirements.txt`, `pyproject.toml`, etc.).
-- **NEVER Commit Without Verification:** You MUST NOT use `git commit` until you have staged the changes and run the project's own verification steps (tests, linter, build).
-
-## 2. Code Development Workflow
-This expands on your core "Execute and Verify" loop with steps specific to coding.
-
-1.  **CRITICAL: Gather Context First:** Before writing or modifying any code, you MUST gather context to ensure your changes are idiomatic and correct.
-    *   **Project Structure & Dependencies:** Check for `README.md`, `package.json`, etc., to understand the project's scripts (lint, test, build).
-    *   **Code Style & Conventions:** Look for `.eslintrc`, `.prettierrc`, `ruff.toml`, etc. Analyze surrounding source files to determine naming conventions, typing style, error handling, and architectural patterns.
-    *   **For new tests:** You MUST read the full source code of the module(s) you are testing.
-    *   **For new features:** You MUST look for existing tests and related modules to understand conventions.
-
-2.  **Implement Idiomatically:** Make the changes, strictly adhering to the patterns and conventions discovered in the context-gathering phase.
-
-3.  **CRITICAL: Design for Testability:** Your primary goal is to produce code that is easy to test automatically.
-    *   **Prefer `return` over `print`:** Core logic functions MUST `return` values. I/O operations like `print()` should be separated into different functions.
-    *   **Embrace Modularity:** Decompose complex tasks into smaller, single-responsibility functions or classes.
-    *   **Use Function Arguments:** Avoid relying on global state. Pass necessary data into functions as arguments.
-
-4.  **Verify with Project Tooling:** After implementation, run all relevant project-specific commands (e.g., `npm run test`, `pytest`, `npm run lint`). This is the verification step for code.
-    *   **CRITICAL:** If any verification step fails, you MUST enter your standard Debugging Loop. You are responsible for fixing the code until all project-specific verifications pass. Do not stop until the code is working correctly.

zrb/task/llm/default_workflow/copywriting.md

@@ -1,17 +0,0 @@
-When the user's request involves creating, refining, or organizing textual content, you MUST follow these domain-specific rules in addition to your core workflow.
-
-## 1. Core Principles
-- **Audience and Tone:** Before writing, always consider the intended audience and the desired tone (e.g., formal, casual, technical, persuasive). If it's not specified, default to a professional and helpful tone.
-- **Structure and Clarity:** Organize content logically. Use headings, bullet points, and bold text to improve readability. Start with a clear topic sentence and build on it.
-- **Originality and Idiom:** Do not plagiarize. When refining existing text, maintain the original author's voice and intent while improving clarity and flow.
-
-## 2. Content Creation Workflow
-1.  **Clarify the Goal:** If the user's request is vague (e.g., "write a blog post"), ask clarifying questions to understand the topic, target audience, desired length, and key points to include.
-2.  **Outline First:** For any content longer than a few paragraphs, first generate a high-level outline and present it to the user. This ensures you are on the right track before generating the full text.
-3.  **Draft and Refine:** Write the full content based on the approved outline. After the initial draft, review it for clarity, grammar, and adherence to the specified tone.
-4.  **Verification:** Read back the final content to the user. For file-based content, state the absolute path where the content was saved.
-
-## 3. Specific Task Guidelines
-- **Summarization:** Identify the main arguments, key findings, and conclusions. Do not inject your own opinions. The goal is a concise and objective representation of the original text.
-- **Translation:** Perform a direct translation, then review it to ensure the phrasing is natural and idiomatic in the target language.
-- **Proofreading:** Correct grammar, spelling, and punctuation errors. Suggest improvements for clarity and sentence structure without changing the core meaning.

zrb/task/llm/default_workflow/researching.md

@@ -1,18 +0,0 @@
-When the user's request involves finding, synthesizing, or analyzing information, you MUST follow these domain-specific rules in addition to your core workflow.
-
-## 1. Core Principles
-- **Objectivity:** Your primary goal is to be an unbiased synthesizer of information. Report the facts as you find them. Do not inject personal opinions or unverified claims.
-- **Source Reliability:** Prioritize reputable sources (e.g., official documentation, academic papers, established news organizations). Be cautious with user-generated content like forums or blogs, and if you must use them, qualify the information (e.g., "According to a user on...").
-- **Synthesis over Recitation:** Do not simply copy-paste large blocks of text. Your value is in synthesizing information from multiple sources to provide a concise, coherent answer.
-
-## 2. Research Workflow
-1.  **Deconstruct the Request:** Break down the user's query into key questions and search terms.
-2.  **Execute Searches:** Use your web search tools to find relevant information. If initial searches fail, try alternative keywords and phrasing.
-3.  **Synthesize Findings:** Read and analyze the search results. Identify the most relevant facts, key arguments, and differing viewpoints.
-4.  **Formulate the Answer:** Structure the answer logically. Start with a direct answer to the user's primary question, then provide supporting details, context, and sources.
-5.  **Cite Your Sources:** For every key fact or claim, you MUST cite the source (e.g., "According to [Source Name](URL), ...").
-
-## 3. Specific Task Guidelines
-- **Summarization:** Extract the main thesis, key arguments, and conclusions from the provided text or URL. The summary must be a concise and accurate representation of the original content.
-- **Comparison:** When asked to compare two or more things, create a structured comparison (e.g., using a table or bullet points) that clearly outlines the key similarities and differences.
-- **Data Analysis:** When working with data (e.g., from a CSV file), state your findings clearly and concisely. If you generate a chart or graph, explain what the visualization shows.

zrb/task/llm/error.py

@@ -1,95 +0,0 @@
-import json
-from typing import TYPE_CHECKING, Any, Optional
-
-if TYPE_CHECKING:
-    from openai import APIError
-
-
-# Define a structured error model for tool execution failures
-class ToolExecutionError:
-    def __init__(
-        self,
-        tool_name: str,
-        error_type: str,
-        message: str,
-        details: Optional[str] = None,
-    ):
-        self.tool_name = tool_name
-        self.error_type = error_type
-        self.message = message
-        self.details = details
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "tool_name": self.tool_name,
-            "error_type": self.error_type,
-            "message": self.message,
-            "details": self.details,
-        }
-
-    def model_dump_json(self, indent: int = 2) -> str:
-        return json.dumps(self.to_dict(), indent=indent)
-
-
-def extract_api_error_details(error: "APIError") -> str:
-    """Extract detailed error information from an APIError."""
-    details = f"{error.message}"
-    # Try to parse the error body as JSON
-    if error.body:
-        try:
-            if isinstance(error.body, str):
-                body_json = json.loads(error.body)
-            elif isinstance(error.body, bytes):
-                body_json = json.loads(error.body.decode("utf-8"))
-            else:
-                body_json = error.body
-            # Extract error details from the JSON structure
-            if isinstance(body_json, dict):
-                if "error" in body_json:
-                    error_obj = body_json["error"]
-                    if isinstance(error_obj, dict):
-                        if "message" in error_obj:
-                            details += f"\nProvider message: {error_obj['message']}"
-                        if "code" in error_obj:
-                            details += f"\nError code: {error_obj['code']}"
-                        if "status" in error_obj:
-                            details += f"\nStatus: {error_obj['status']}"
-                # Check for metadata that might contain provider-specific information
-                if "metadata" in body_json and isinstance(body_json["metadata"], dict):
-                    metadata = body_json["metadata"]
-                    if "provider_name" in metadata:
-                        details += f"\nProvider: {metadata['provider_name']}"
-                    if "raw" in metadata:
-                        try:
-                            raw_json = json.loads(metadata["raw"])
-                            if "error" in raw_json and isinstance(
-                                raw_json["error"], dict
-                            ):
-                                raw_error = raw_json["error"]
-                                if "message" in raw_error:
-                                    details += (
-                                        f"\nRaw error message: {raw_error['message']}"
-                                    )
-                        except (KeyError, TypeError, ValueError):
-                            # If we can't parse the raw JSON, just include it as is
-                            details += f"\nRaw error data: {metadata['raw']}"
-        except json.JSONDecodeError:
-            # If we can't parse the JSON, include the raw body
-            details += f"\nRaw error body: {error.body}"
-        except Exception as e:
-            # Catch any other exceptions during parsing
-            details += f"\nError parsing error body: {str(e)}"
-    # Include request information if available
-    if hasattr(error, "request") and error.request:
-        if hasattr(error.request, "method") and hasattr(error.request, "url"):
-            details += f"\nRequest: {error.request.method} {error.request.url}"
-        # Include a truncated version of the request content if available
-        if hasattr(error.request, "content") and error.request.content:
-            content = error.request.content
-            if isinstance(content, bytes):
-                try:
-                    content = content.decode("utf-8")
-                except UnicodeDecodeError:
-                    content = str(content)
-            details += f"\nRequest content: {content}"
-    return details

zrb/task/llm/history_summarization.py

@@ -1,216 +0,0 @@
-import json
-import traceback
-from typing import TYPE_CHECKING
-
-from zrb.attr.type import BoolAttr, IntAttr
-from zrb.config.llm_config import llm_config
-from zrb.config.llm_rate_limitter import LLMRateLimiter, llm_rate_limitter
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.agent import run_agent_iteration
-from zrb.task.llm.conversation_history import (
-    count_part_in_history_list,
-    replace_system_prompt_in_history,
-)
-from zrb.task.llm.conversation_history_model import ConversationHistory
-from zrb.task.llm.typing import ListOfDict
-from zrb.util.attr import get_bool_attr, get_int_attr
-from zrb.util.cli.style import stylize_faint
-from zrb.util.llm.prompt import make_prompt_section
-
-if TYPE_CHECKING:
-    from pydantic_ai.models import Model
-    from pydantic_ai.settings import ModelSettings
-
-
-def _count_token_in_history(history_list: ListOfDict) -> int:
-    """Counts the total number of tokens in a conversation history list."""
-    text_to_count = json.dumps(history_list)
-    return llm_rate_limitter.count_token(text_to_count)
-
-
-def get_history_summarization_token_threshold(
-    ctx: AnyContext,
-    history_summarization_token_threshold_attr: IntAttr | None,
-    render_history_summarization_token_threshold: bool,
-) -> int:
-    """Gets the history summarization token threshold, handling defaults and errors."""
-    try:
-        return get_int_attr(
-            ctx,
-            history_summarization_token_threshold_attr,
-            llm_config.default_history_summarization_token_threshold,
-            auto_render=render_history_summarization_token_threshold,
-        )
-    except ValueError as e:
-        ctx.log_warning(
-            f"Could not convert history_summarization_token_threshold to int: {e}. "
-            "Defaulting to -1 (no threshold)."
-        )
-        return -1
-
-
-def should_summarize_history(
-    ctx: AnyContext,
-    history_list: ListOfDict,
-    should_summarize_history_attr: BoolAttr | None,
-    render_summarize_history: bool,
-    history_summarization_token_threshold_attr: IntAttr | None,
-    render_history_summarization_token_threshold: bool,
-) -> bool:
-    """Determines if history summarization should occur based on token length and config."""
-    history_part_count = count_part_in_history_list(history_list)
-    if history_part_count == 0:
-        return False
-    summarization_token_threshold = get_history_summarization_token_threshold(
-        ctx,
-        history_summarization_token_threshold_attr,
-        render_history_summarization_token_threshold,
-    )
-    history_token_count = _count_token_in_history(history_list)
-    if (
-        summarization_token_threshold == -1
-        or summarization_token_threshold > history_token_count
-    ):
-        return False
-    return get_bool_attr(
-        ctx,
-        should_summarize_history_attr,
-        llm_config.default_summarize_history,
-        auto_render=render_summarize_history,
-    )
-
-
-async def summarize_history(
-    ctx: AnyContext,
-    model: "Model | str | None",
-    settings: "ModelSettings | None",
-    system_prompt: str,
-    conversation_history: ConversationHistory,
-    rate_limitter: LLMRateLimiter | None = None,
-    retries: int = 3,
-) -> str:
-    """Runs an LLM call to update the conversation summary."""
-    from pydantic_ai import Agent
-
-    ctx.log_info("Attempting to summarize conversation history...")
-    # Construct the user prompt for the summarization agent
-    user_prompt = "\n".join(
-        [
-            make_prompt_section(
-                "Past Conversation",
-                "\n".join(
-                    [
-                        make_prompt_section(
-                            "Summary",
-                            conversation_history.past_conversation_summary,
-                            as_code=True,
-                        ),
-                        make_prompt_section(
-                            "Last Transcript",
-                            conversation_history.past_conversation_transcript,
-                            as_code=True,
-                        ),
-                    ]
-                ),
-            ),
-            make_prompt_section(
-                "Recent Conversation (JSON)",
-                json.dumps(conversation_history.history),
-                as_code=True,
-            ),
-            make_prompt_section(
-                "Notes",
-                "\n".join(
-                    [
-                        make_prompt_section(
-                            "Long Term",
-                            conversation_history.long_term_note,
-                            as_code=True,
-                        ),
-                        make_prompt_section(
-                            "Contextual",
-                            conversation_history.contextual_note,
-                            as_code=True,
-                        ),
-                    ]
-                ),
-            ),
-        ]
-    )
-    summarization_agent = Agent(
-        model=model,
-        system_prompt=system_prompt,
-        model_settings=settings,
-        retries=retries,
-        tools=[
-            conversation_history.write_past_conversation_summary,
-            conversation_history.write_past_conversation_transcript,
-            conversation_history.read_long_term_note,
-            conversation_history.write_long_term_note,
-            conversation_history.read_contextual_note,
-            conversation_history.write_contextual_note,
-        ],
-    )
-    try:
-        ctx.print(stylize_faint("📝 Summarize Conversation >>>"), plain=True)
-        summary_run = await run_agent_iteration(
-            ctx=ctx,
-            agent=summarization_agent,
-            user_prompt=user_prompt,
-            attachments=[],
-            history_list=[],
-            rate_limitter=rate_limitter,
-        )
-        if summary_run and summary_run.result and summary_run.result.output:
-            usage = summary_run.result.usage()
-            ctx.print(stylize_faint(f"📝 Summarization Token: {usage}"), plain=True)
-            ctx.print(plain=True)
-            ctx.log_info("History summarized and updated.")
-        else:
-            ctx.log_warning("History summarization failed or returned no data.")
-    except BaseException as e:
-        ctx.log_warning(f"Error during history summarization: {e}")
-        traceback.print_exc()
-    # Return the original summary if summarization fails
-    return conversation_history
-
-
-async def maybe_summarize_history(
-    ctx: AnyContext,
-    conversation_history: ConversationHistory,
-    should_summarize_history_attr: BoolAttr | None,
-    render_summarize_history: bool,
-    history_summarization_token_threshold_attr: IntAttr | None,
-    render_history_summarization_token_threshold: bool,
-    model: "str | Model | None",
-    model_settings: "ModelSettings | None",
-    summarization_prompt: str,
-    rate_limitter: LLMRateLimiter | None = None,
-) -> ConversationHistory:
-    """Summarizes history and updates context if enabled and threshold met."""
-    shorten_history = replace_system_prompt_in_history(conversation_history.history)
-    if should_summarize_history(
-        ctx,
-        shorten_history,
-        should_summarize_history_attr,
-        render_summarize_history,
-        history_summarization_token_threshold_attr,
-        render_history_summarization_token_threshold,
-    ):
-        original_history = conversation_history.history
-        conversation_history.history = shorten_history
-        conversation_history = await summarize_history(
-            ctx=ctx,
-            model=model,
-            settings=model_settings,
-            system_prompt=summarization_prompt,
-            conversation_history=conversation_history,
-            rate_limitter=rate_limitter,
-        )
-        conversation_history.history = original_history
-        if (
-            conversation_history.past_conversation_summary != ""
-            and conversation_history.past_conversation_transcript != ""
-        ):
-            conversation_history.history = []
-    return conversation_history