zrb 1.8.10__py3-none-any.whl → 1.21.29__py3-none-any.whl

zrb/task/llm/agent_runner.py

@@ -0,0 +1,152 @@
+import json
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
+
+from zrb.config.llm_rate_limitter import LLMRateLimitter, llm_rate_limitter
+from zrb.context.any_context import AnyContext
+from zrb.task.llm.error import extract_api_error_details
+from zrb.task.llm.print_node import print_node
+from zrb.task.llm.typing import ListOfDict
+from zrb.util.cli.style import stylize_faint
+
+if TYPE_CHECKING:
+    from pydantic_ai import Agent, Tool
+    from pydantic_ai.agent import AgentRun
+    from pydantic_ai.messages import UserContent
+
+    ToolOrCallable = Tool | Callable
+
+
+async def run_agent_iteration(
+    ctx: AnyContext,
+    agent: "Agent[None, Any]",
+    user_prompt: str,
+    attachments: "list[UserContent] | None" = None,
+    history_list: ListOfDict | None = None,
+    rate_limitter: LLMRateLimitter | None = None,
+    max_retry: int = 2,
+    log_indent_level: int = 0,
+) -> "AgentRun":
+    """
+    Runs a single iteration of the agent execution loop.
+
+    Args:
+        ctx: The task context.
+        agent: The Pydantic AI agent instance.
+        user_prompt: The user's input prompt.
+        history_list: The current conversation history.
+
+    Returns:
+        The agent run result object.
+
+    Raises:
+        Exception: If any error occurs during agent execution.
+    """
+    if max_retry < 0:
+        raise ValueError("Max retry cannot be less than 0")
+    attempt = 0
+    while attempt < max_retry:
+        try:
+            return await _run_single_agent_iteration(
+                ctx=ctx,
+                agent=agent,
+                user_prompt=user_prompt,
+                attachments=[] if attachments is None else attachments,
+                history_list=[] if history_list is None else history_list,
+                rate_limitter=(
+                    llm_rate_limitter if rate_limitter is None else rate_limitter
+                ),
+                log_indent_level=log_indent_level,
+            )
+        except BaseException:
+            attempt += 1
+            if attempt == max_retry:
+                raise
+    raise Exception("Max retry exceeded")
+
+
+async def _run_single_agent_iteration(
+    ctx: AnyContext,
+    agent: "Agent",
+    user_prompt: str,
+    attachments: "list[UserContent]",
+    history_list: ListOfDict,
+    rate_limitter: LLMRateLimitter,
+    log_indent_level: int,
+) -> "AgentRun":
+    from openai import APIError
+    from pydantic_ai import UsageLimits
+    from pydantic_ai.messages import ModelMessagesTypeAdapter
+
+    agent_payload = _estimate_request_payload(
+        agent, user_prompt, attachments, history_list
+    )
+    callback = _create_print_throttle_notif(ctx)
+    if rate_limitter:
+        await rate_limitter.throttle(agent_payload, callback)
+    else:
+        await llm_rate_limitter.throttle(agent_payload, callback)
+    user_prompt_with_attachments = [user_prompt] + attachments
+    async with agent:
+        async with agent.iter(
+            user_prompt=user_prompt_with_attachments,
+            message_history=ModelMessagesTypeAdapter.validate_python(history_list),
+            usage_limits=UsageLimits(request_limit=None),  # We don't want limit
+        ) as agent_run:
+            async for node in agent_run:
+                # Each node represents a step in the agent's execution
+                try:
+                    await print_node(
+                        _get_plain_printer(ctx), agent_run, node, log_indent_level
+                    )
+                except APIError as e:
+                    # Extract detailed error information from the response
+                    error_details = extract_api_error_details(e)
+                    ctx.log_error(f"API Error: {error_details}")
+                    raise
+                except Exception as e:
+                    ctx.log_error(f"Error processing node: {str(e)}")
+                    ctx.log_error(f"Error type: {type(e).__name__}")
+                    raise
+            return agent_run
+
+
+def _create_print_throttle_notif(ctx: AnyContext) -> Callable[[str], None]:
+    def _print_throttle_notif(reason: str):
+        ctx.print(stylize_faint(f"  ⌛>> Request Throttled: {reason}"), plain=True)
+
+    return _print_throttle_notif
+
+
+def _estimate_request_payload(
+    agent: "Agent",
+    user_prompt: str,
+    attachments: "list[UserContent]",
+    history_list: ListOfDict,
+) -> str:
+    system_prompts = agent._system_prompts if hasattr(agent, "_system_prompts") else ()
+    return json.dumps(
+        [
+            {"role": "system", "content": "\n".join(system_prompts)},
+            *history_list,
+            {"role": "user", "content": user_prompt},
+            *[_estimate_attachment_payload(attachment) for attachment in attachments],
+        ]
+    )
+
+
+def _estimate_attachment_payload(attachment: "UserContent") -> Any:
+    if hasattr(attachment, "url"):
+        return {"role": "user", "content": attachment.url}
+    if hasattr(attachment, "data"):
+        return {"role": "user", "content": "x" * len(attachment.data)}
+    return ""
+
+
+def _get_plain_printer(ctx: AnyContext):
+    def printer(*args, **kwargs):
+        if "plain" not in kwargs:
+            kwargs["plain"] = True
+        return ctx.print(*args, **kwargs)
+
+    return printer

zrb/task/llm/config.py

@@ -1,25 +1,45 @@
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     from pydantic_ai.models import Model
     from pydantic_ai.settings import ModelSettings
-else:
-    Model = Any
-    ModelSettings = Any
 
-from zrb.attr.type import StrAttr, fstring
+from zrb.attr.type import BoolAttr, StrAttr, StrListAttr
+from zrb.config.llm_config import LLMConfig, llm_config
 from zrb.context.any_context import AnyContext
-from zrb.context.any_shared_context import AnySharedContext
-from zrb.llm_config import LLMConfig, llm_config
-from zrb.util.attr import get_attr
+from zrb.util.attr import get_attr, get_bool_attr, get_str_list_attr
+
+
+def get_yolo_mode(
+    ctx: AnyContext,
+    yolo_mode_attr: (
+        Callable[[AnyContext], list[str] | bool | None] | StrListAttr | BoolAttr | None
+    ) = None,
+    render_yolo_mode: bool = True,
+) -> bool | list[str]:
+    if yolo_mode_attr is None:
+        return llm_config.default_yolo_mode
+    try:
+        return get_bool_attr(
+            ctx,
+            yolo_mode_attr,
+            False,
+            auto_render=render_yolo_mode,
+        )
+    except Exception:
+        return get_str_list_attr(
+            ctx,
+            yolo_mode_attr,
+            auto_render=render_yolo_mode,
+        )
 
 
 def get_model_settings(
     ctx: AnyContext,
     model_settings_attr: (
-        ModelSettings | Callable[[AnySharedContext], ModelSettings] | None
+        "ModelSettings | Callable[[AnyContext], ModelSettings] | None"
     ) = None,
-) -> ModelSettings | None:
+) -> "ModelSettings | None":
     """Gets the model settings, resolving callables if necessary."""
     model_settings = get_attr(ctx, model_settings_attr, None, auto_render=False)
     if model_settings is None:
@@ -50,7 +70,7 @@ def get_model_api_key(
 ) -> str | None:
     """Gets the model API key, rendering if configured."""
     api_key = get_attr(ctx, model_api_key_attr, None, auto_render=render_model_api_key)
-    if api_key is None and llm_config.default_api_key is not None:
+    if api_key is None and llm_config.default_model_api_key is not None:
         return llm_config.default_model_api_key
     if isinstance(api_key, str) or api_key is None:
         return api_key
@@ -59,18 +79,21 @@ def get_model_api_key(
 
 def get_model(
     ctx: AnyContext,
-    model_attr: Callable[[AnySharedContext], Model | str | fstring] | Model | None,
+    model_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
     render_model: bool,
-    model_base_url_attr: StrAttr | None = None,
+    model_base_url_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
     render_model_base_url: bool = True,
-    model_api_key_attr: StrAttr | None = None,
+    model_api_key_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None" = None,
     render_model_api_key: bool = True,
-) -> str | Model | None:
+    is_small_model: bool = False,
+) -> "str | Model":
     """Gets the model instance or name, handling defaults and configuration."""
     from pydantic_ai.models import Model
 
     model = get_attr(ctx, model_attr, None, auto_render=render_model)
     if model is None:
+        if is_small_model:
+            return llm_config.default_small_model
         return llm_config.default_model
     if isinstance(model, str):
         model_base_url = get_model_base_url(
@@ -79,11 +102,11 @@ def get_model(
         model_api_key = get_model_api_key(ctx, model_api_key_attr, render_model_api_key)
         new_llm_config = LLMConfig(
             default_model_name=model,
-            default_base_url=model_base_url,
-            default_api_key=model_api_key,
+            default_model_base_url=model_base_url,
+            default_model_api_key=model_api_key,
         )
         if model_base_url is None and model_api_key is None:
-            default_model_provider = llm_config.default_model_provider
+            default_model_provider = _get_default_model_provider(is_small_model)
             if default_model_provider is not None:
                 new_llm_config.set_default_model_provider(default_model_provider)
         return new_llm_config.default_model
@@ -91,3 +114,9 @@ def get_model(
     if isinstance(model, Model):
         return model
     raise ValueError(f"Invalid model type resolved: {type(model)}, value: {model}")
+
+
+def _get_default_model_provider(is_small_model: bool = False):
+    if is_small_model:
+        return llm_config.default_small_model_provider
+    return llm_config.default_model_provider

zrb/task/llm/conversation_history.py

@@ -0,0 +1,209 @@
+import json
+import os
+from collections.abc import Callable
+from typing import Any
+
+from zrb.attr.type import StrAttr
+from zrb.config.llm_context.config import llm_context_config
+from zrb.context.any_context import AnyContext
+from zrb.task.llm.conversation_history_model import ConversationHistory
+from zrb.task.llm.typing import ListOfDict
+from zrb.util.attr import get_str_attr
+from zrb.util.file import read_file, write_file
+from zrb.util.markdown import make_markdown_section
+from zrb.util.run import run_async
+from zrb.xcom.xcom import Xcom
+
+
+def _get_global_subagent_messages_xcom(ctx: AnyContext) -> Xcom:
+    if "_global_subagents" not in ctx.xcom:
+        ctx.xcom["_global_subagents"] = Xcom([{}])
+    if not isinstance(ctx.xcom["_global_subagents"], Xcom):
+        raise ValueError("ctx.xcom._global_subagents must be an Xcom")
+    return ctx.xcom["_global_subagents"]
+
+
+def inject_subagent_history_into_ctx(
+    ctx: AnyContext, conversation_history: ConversationHistory
+):
+    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
+    existing_subagent_history = subagent_messages_xcom.get({})
+    subagent_messages_xcom.set(
+        {**existing_subagent_history, **conversation_history.subagent_history}
+    )
+
+
+def set_ctx_subagent_history(ctx: AnyContext, subagent_name: str, messages: ListOfDict):
+    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
+    subagent_history = subagent_messages_xcom.get({})
+    subagent_history[subagent_name] = messages
+    subagent_messages_xcom.set(subagent_history)
+
+
+def get_subagent_histories_from_ctx(ctx: AnyContext) -> dict[str, ListOfDict]:
+    subagent_messsages_xcom = _get_global_subagent_messages_xcom(ctx)
+    return subagent_messsages_xcom.get({})
+
+
+def inject_conversation_history_notes(conversation_history: ConversationHistory):
+    conversation_history.long_term_note = _fetch_long_term_note(
+        conversation_history.project_path
+    )
+    conversation_history.contextual_note = _fetch_contextual_note(
+        conversation_history.project_path
+    )
+
+
+def _fetch_long_term_note(project_path: str) -> str:
+    contexts = llm_context_config.get_notes(cwd=project_path)
+    return contexts.get("/", "")
+
+
+def _fetch_contextual_note(project_path: str) -> str:
+    contexts = llm_context_config.get_notes(cwd=project_path)
+    return "\n".join(
+        [
+            make_markdown_section(header, content)
+            for header, content in contexts.items()
+            if header != "/"
+        ]
+    )
+
+
+def get_history_file(
+    ctx: AnyContext,
+    conversation_history_file_attr: StrAttr | None,
+    render_history_file: bool,
+) -> str:
+    """Gets the path to the conversation history file, rendering if configured."""
+    return get_str_attr(
+        ctx,
+        conversation_history_file_attr,
+        "",
+        auto_render=render_history_file,
+    )
+
+
+async def _read_from_source(
+    ctx: AnyContext,
+    reader: (
+        Callable[[AnyContext], ConversationHistory | 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 = ConversationHistory.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 = ConversationHistory.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
+
+
+async def read_conversation_history(
+    ctx: AnyContext,
+    conversation_history_reader: (
+        Callable[[AnyContext], ConversationHistory | dict | list | None] | None
+    ),
+    conversation_history_file_attr: StrAttr | None,
+    render_history_file: bool,
+    conversation_history_attr: (
+        ConversationHistory
+        | Callable[[AnyContext], ConversationHistory | dict | list]
+        | dict
+        | list
+    ),
+) -> ConversationHistory:
+    """Reads conversation history from reader, file, or attribute, with validation."""
+    history_file = get_history_file(
+        ctx, conversation_history_file_attr, render_history_file
+    )
+    # Use the class method defined above
+    history_data = await _read_from_source(
+        ctx=ctx,
+        reader=conversation_history_reader,
+        file_path=history_file,
+    )
+    if history_data:
+        return history_data
+    # Priority 3: Callable or direct conversation_history attribute
+    raw_data_attr: Any = None
+    if callable(conversation_history_attr):
+        try:
+            raw_data_attr = await run_async(conversation_history_attr(ctx))
+        except Exception as e:
+            ctx.log_warning(
+                f"Error executing callable conversation_history attribute: {e}. "
+                "Ignoring."
+            )
+    if raw_data_attr is None:
+        raw_data_attr = conversation_history_attr
+    if raw_data_attr:
+        # Use the class method defined above
+        history_data = ConversationHistory.parse_and_validate(
+            ctx, raw_data_attr, "attribute"
+        )
+        if history_data:
+            return history_data
+    # Fallback: Return default value
+    return ConversationHistory()
+
+
+async def write_conversation_history(
+    ctx: AnyContext,
+    history_data: ConversationHistory,
+    conversation_history_writer: (
+        Callable[[AnyContext, ConversationHistory], None] | None
+    ),
+    conversation_history_file_attr: StrAttr | None,
+    render_history_file: bool,
+):
+    """Writes conversation history using the writer or to a file."""
+    if conversation_history_writer is not None:
+        await run_async(conversation_history_writer(ctx, history_data))
+    history_file = get_history_file(
+        ctx, conversation_history_file_attr, render_history_file
+    )
+    if history_file != "":
+        write_file(history_file, json.dumps(history_data.to_dict(), indent=2))
+
+
+def count_part_in_history_list(history_list: ListOfDict) -> int:
+    """Calculates the total number of 'parts' in a history list."""
+    history_part_len = 0
+    for history in history_list:
+        if "parts" in history:
+            history_part_len += len(history["parts"])
+        else:
+            history_part_len += 1
+    return history_part_len

zrb/task/llm/conversation_history_model.py

@@ -0,0 +1,67 @@
+import json
+import os
+from typing import Any
+
+from zrb.context.any_context import AnyContext
+from zrb.task.llm.typing import ListOfDict
+
+
+class ConversationHistory:
+
+    def __init__(
+        self,
+        history: ListOfDict | None = None,
+        contextual_note: str | None = None,
+        long_term_note: str | None = None,
+        project_path: str | None = None,
+        subagent_history: dict[str, ListOfDict] | None = None,
+    ):
+        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()
+        self.subagent_history = subagent_history if subagent_history is not None else {}
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "history": self.history,
+            "contextual_note": self.contextual_note,
+            "long_term_note": self.long_term_note,
+            "subagent_history": self.subagent_history,
+        }
+
+    def model_dump_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+    @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):
+                return cls(
+                    history=data.get("history", data.get("messages", [])),
+                    contextual_note=data.get("contextual_note", ""),
+                    long_term_note=data.get("long_term_note", ""),
+                    subagent_history=data.get("subagent_history", {}),
+                )
+            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()

zrb/task/llm/default_workflow/coding/workflow.md

@@ -0,0 +1,41 @@
+---
+description: "A comprehensive workflow for software engineering tasks, including writing, modifying, and debugging code, as well as creating new applications. ALWAYS activate this workflow whenever you need to deal with software engineering tasks."
+---
+
+This workflow provides a structured approach to software engineering tasks. Adhere to these guidelines to deliver high-quality, idiomatic code that respects the project's existing patterns and conventions.
+
+# Workflow Loading Strategy
+
+This is a general-purpose coding workflow. For tasks involving specific languages or tools, you **MUST** load the relevant specialized workflows.
+
+- **If the task involves Python:** Load the `python` workflow.
+- **If the task involves Git:** Load the `git` workflow.
+- **If the task involves shell scripting:** Load the `shell` workflow.
+- **If the task involves Go:** Load the `golang` workflow.
+- **If the task involves Java:** Load the `java` workflow.
+- **If the task involves Javascript/Typescript:** Load the `javascript` workflow.
+- **If the task involves HTML/CSS:** Load the `html-css` workflow.
+- **If the task involves Rust:** Load the `rust` workflow.
+
+Always consider if a more specific workflow is available and appropriate for the task at hand.
+
+# Core Mandates
+
+- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
+- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
+- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
+- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
+- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
+- **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
+- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
+- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
+- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
+
+# Software Engineering Tasks
+When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
+1. **Understand & Strategize:** Think about the user's request and the relevant codebase context. When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary tool** must be 'codebase_investigator'. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use 'search_file_content' or 'glob' directly.
+2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
+3. **Implement:** Use the available tools (e.g., 'replace_in_file', 'write_to_file' 'run_shell_command' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
+4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
+5. **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
+6. **Finalize:** After all verification passes, consider the task complete. Do not remove or revert any changes or created files (like tests). Await the user's next instruction.

zrb/task/llm/default_workflow/copywriting/workflow.md

@@ -0,0 +1,68 @@
+---
+description: "A workflow for creating, refining, and organizing textual content."
+---
+Follow this workflow to produce content that is not just correct, but compelling, clear, and perfectly suited to its purpose.
+
+# Core Mandates
+
+- **Audience-First:** Always understand who you're writing for and what they need to know
+- **Purpose-Driven:** Every piece of content must serve a clear objective
+- **Quality Standards:** Deliver polished, professional content that meets the highest standards
+- **Iterative Refinement:** Content improves through multiple rounds of review and editing
+
+# Tool Usage Guideline
+- Use `read_from_file` to analyze existing content and style guides
+- Use `write_to_file` for creating new content drafts
+- Use `replace_in_file` for targeted edits and refinements
+
+# Step 1: Understand Intent and Audience
+
+1. **Define the Goal:** What is this text supposed to achieve? (e.g., persuade, inform, entertain, sell). If the user is vague, ask for clarification.
+2. **Identify the Audience:** Who are you writing for? (e.g., experts, beginners, customers). This dictates your tone, vocabulary, and level of detail.
+3. **Determine the Tone:** Choose a voice that serves the goal and resonates with the audience (e.g., formal, witty, technical, urgent).
+4. **Analyze Existing Content:** Review any provided examples, style guides, or reference materials to understand established patterns.
+
+# Step 2: Plan and Outline
+
+1. **Create Logical Structure:** Develop an outline that flows naturally from introduction to conclusion
+2. **Key Sections:** Identify main talking points and supporting arguments
+3. **Call-to-Action:** Define what you want the reader to do or think after reading
+4. **Get Approval:** Present the outline to the user for confirmation before proceeding
+
+# Step 3: Draft with Purpose
+
+1. **Hook the Reader:** Start with a strong opening that grabs attention
+2. **Use Active Voice:** Make your writing direct and energetic
+3. **Show, Don't Just Tell:** Use examples, stories, and data to illustrate your points
+4. **Maintain Consistency:** Stick to the established tone and style throughout
+
+# Step 4: Refine and Polish
+
+1. **Read Aloud:** Catch awkward phrasing and grammatical errors
+2. **Cut Mercilessly:** Remove anything that doesn't serve the goal
+3. **Enhance Readability:** Use short paragraphs, headings, bullet points, and bold text
+4. **Verify Accuracy:** Ensure all facts, figures, and claims are correct
+
+# Step 5: Task-Specific Execution
+
+## Summarization
+- Distill the essence while preserving key information
+- Be objective and ruthless in cutting fluff
+- Maintain the original meaning and context
+
+## Proofreading
+- Correct grammar, spelling, and punctuation
+- Improve sentence flow and clarity
+- Preserve the original meaning and voice
+
+## Refining/Editing
+- Sharpen the author's message
+- Strengthen arguments and improve clarity
+- Ensure consistent tone while respecting the original voice
+
+# Step 6: Finalize and Deliver
+
+- Present the final content to the user
+- Be prepared to make additional refinements based on feedback
+- Ensure the content meets all stated objectives
+- Confirm the content is ready for its intended use