arcade-google-docs 4.0.0__py3-none-any.whl → 4.2.0__py3-none-any.whl

arcade_google_docs/tools/__init__.py

@@ -12,6 +12,7 @@ from arcade_google_docs.tools.search import (
     search_and_retrieve_documents,
     search_documents,
 )
+from arcade_google_docs.tools.system_context import who_am_i
 from arcade_google_docs.tools.update import insert_text_at_end_of_document
 
 __all__ = [
@@ -24,4 +25,5 @@ __all__ = [
     "search_and_retrieve_documents",
     "search_documents",
     "generate_google_file_picker_url",
+    "who_am_i",
 ]

arcade_google_docs/tools/edit_agent/edit_agent.py

@@ -0,0 +1,56 @@
+from typing import Annotated
+
+from arcade_tdk import ToolContext, tool
+from arcade_tdk.auth import Google
+from openai import OpenAI
+
+from arcade_google_docs.tools.edit_agent.executor import execute_plan
+from arcade_google_docs.tools.edit_agent.models.planning import ReasoningEffort
+from arcade_google_docs.tools.edit_agent.planner import plan_edits
+from arcade_google_docs.tools.edit_agent.progress_tracker import ExecutionProgressTracker
+from arcade_google_docs.tools.edit_agent.utils import get_docmd
+from arcade_google_docs.utils import build_docs_service
+
+
+@tool(
+    requires_auth=Google(
+        scopes=[
+            "https://www.googleapis.com/auth/drive.file",
+        ],
+    ),
+    requires_secrets=["OPENAI_API_KEY"],
+)
+async def edit_document(
+    context: ToolContext,
+    document_id: Annotated[str, "The ID of the document to edit"],
+    edit_requests: Annotated[
+        list[str],
+        "A list of natural language descriptions of the desired change(s) to the document. "
+        "Each entry should be a single, self-contained edit request that can be fully understood "
+        "independently. Note: Each request may result in zero, one, or multiple actual edits "
+        "depending on what changes are needed (e.g., a request might be ignored if the change "
+        "already exists in the document).",
+    ],
+    reasoning_effort: Annotated[
+        ReasoningEffort, "The effort to put into reasoning about the edit(s). Defaults to medium"
+    ] = ReasoningEffort.MEDIUM,
+) -> Annotated[dict, "The edited document's title, documentId, and documentUrl in a dictionary"]:
+    """
+    Edit a Google Docs document with the specified edit request.
+
+    This tool does not have context about previous edits because it is stateless. If your edit
+    request depends on knowledge about previous edits, then you should provide that context in
+    the edit requests.
+    """
+    progress = ExecutionProgressTracker()
+    progress.add(f"Starting to create a plan with '{reasoning_effort.value}' reasoning effort")
+
+    openai_client = OpenAI(api_key=context.get_secret("OPENAI_API_KEY"))
+    google_service = build_docs_service(context.get_auth_token_or_empty())
+    docmd = get_docmd(google_service, document_id)
+
+    plan = await plan_edits(openai_client, docmd, edit_requests, reasoning_effort, progress)
+
+    result = await execute_plan(openai_client, google_service, docmd, document_id, plan, progress)
+
+    return result

arcade_google_docs/tools/edit_agent/executor.py

@@ -0,0 +1,103 @@
+"""Execution service for the edit agent."""
+
+from typing import Any
+
+from arcade_tdk.errors import ToolExecutionError
+from openai import OpenAI
+
+from arcade_google_docs.docmd import DocMD
+from arcade_google_docs.tools.edit_agent.models.planning import Plan
+from arcade_google_docs.tools.edit_agent.progress_tracker import ExecutionProgressTracker
+from arcade_google_docs.tools.edit_agent.request_generator import generate_api_request_for_step
+from arcade_google_docs.tools.edit_agent.utils import get_docmd
+
+
+async def execute_plan(
+    openai_client: OpenAI,
+    google_service: Any,
+    docmd: DocMD,
+    document_id: str,
+    plan: Plan,
+    progress: ExecutionProgressTracker,
+) -> dict:
+    """
+    Execute a plan step by step.
+
+    Returns a dictionary with responses, edit_requests, and execution_logs.
+    """
+    if plan.number_of_steps == 0:
+        progress.add("I was unable to come up with a plan to edit the document")
+        return {
+            "responses": [],
+            "edit_requests": [],
+            "execution_logs": progress.get_messages(),
+        }
+
+    progress.add(
+        f"I have a {plan.number_of_steps} step plan where I will perform "
+        f"{plan.number_of_edit_requests} edit(s)"
+    )
+    progress.add(f"I need to execute the following plan:\n{plan.to_log_string()}")
+
+    progress.add("Starting to execute on the plan...")
+    all_google_edit_responses = []
+    all_requests = []
+
+    # Execute the plan step by step. Within each step, execute all items in parallel
+    for step_num, step in enumerate(plan.steps):
+        progress.add_step_start(step_num, len(plan.steps))
+
+        # Refresh document state before each step (except the first one)
+        if step_num > 0:
+            docmd = get_docmd(google_service, document_id)
+
+        step_requests = await generate_api_request_for_step(
+            openai_client,
+            docmd,
+            step,
+        )
+
+        error: str | None = None
+        failed_requests = step_requests
+
+        for attempt in range(2):
+            try:
+                if attempt == 1:
+                    # Regenerate on retry with error context
+                    step_requests = await generate_api_request_for_step(
+                        openai_client,
+                        docmd,
+                        step,
+                        previous_error=error,
+                        failed_requests=failed_requests,
+                    )
+
+                # All requests in the step are sent in a single batchUpdate call
+                if step_requests:
+                    google_edit_response = (
+                        google_service.documents()
+                        .batchUpdate(documentId=document_id, body={"requests": step_requests})
+                        .execute()
+                    )
+                    all_google_edit_responses.append(google_edit_response)
+                    all_requests.extend(step_requests)
+
+                progress.add_step_success(step_num, len(plan.steps))
+                break
+            except Exception as e:
+                progress.add_step_error(step_num, len(plan.steps), e)
+                if attempt == 0:
+                    error = str(e)
+                    failed_requests = step_requests
+                    progress.add_step_retry(step_num, len(plan.steps))
+                    continue
+                raise ToolExecutionError(
+                    message=f"Failed to execute step {step_num + 1} after 2 attempts",
+                    developer_message="\n".join(progress.get_messages()),
+                )
+
+    return {
+        "responses": all_google_edit_responses,
+        "edit_requests": all_requests,
+        "execution_logs": progress.get_messages(),
+    }

arcade_google_docs/tools/edit_agent/models/planning.py

@@ -0,0 +1,89 @@
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from arcade_google_docs.models.requests import EditRequestType
+
+
+class ReasoningEffort(str, Enum):
+    MINIMAL = "minimal"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+
+    def minimum_number_of_thoughts(self) -> int:
+        return {
+            ReasoningEffort.MINIMAL: 0,
+            ReasoningEffort.LOW: 1,
+            ReasoningEffort.MEDIUM: 2,
+            ReasoningEffort.HIGH: 3,
+        }[self]
+
+
+class EditItem(BaseModel):
+    """A single edit request with its type and associated thoughts"""
+
+    edit_request_type: EditRequestType = Field(
+        ..., title="The type of edit request to be made to the document"
+    )
+    edit_instruction: str = Field(
+        ..., title="Natural language description of the desired change to the document"
+    )
+    thoughts: list[str] = Field(
+        ..., title="Thoughts that led to identifying this specific edit request"
+    )
+
+
+class Step(BaseModel):
+    """A step containing one or more edit requests to be executed together"""
+
+    model_config = ConfigDict(
+        title="Step for Document Editing",
+        json_schema_extra={
+            "description": "A step containing edit requests that can be executed together",
+            "examples": [
+                {
+                    "edit_items": [
+                        {
+                            "edit_request_type": "updateTextStyle",
+                            "edit_instruction": "Make 'Performance' bold in the objectives section",
+                            "thoughts": [
+                                "(thought) I am asked to make 'Performance' bold in the "
+                                "objectives section",
+                                "(thought) I need to find where 'Performance' appears",
+                                "(thought) 'Performance' is at index 150-161 in the document",
+                                "(thought) I'll use updateTextStyle to make it bold",
+                            ],
+                        },
+                    ],
+                }
+            ],
+        },
+    )
+    edit_items: list[EditItem] = Field(
+        ..., title="List of edit requests to be executed in this step"
+    )
+
+
+class Plan(BaseModel):
+    """The final ordered plan with proper dependencies"""
+
+    steps: list[Step] = Field(
+        ..., title="Ordered list of steps, each containing one or more edit requests"
+    )
+
+    @property
+    def number_of_steps(self) -> int:
+        return len(self.steps)
+
+    @property
+    def number_of_edit_requests(self) -> int:
+        return sum(len(step.edit_items) for step in self.steps)
+
+    def to_log_string(self) -> str:
+        log_string = ""
+        for step_num, step in enumerate(self.steps):
+            log_string += f"Step {step_num + 1}:\n"
+            for edit_item in step.edit_items:
+                log_string += f"  - {edit_item.edit_instruction}\n"
+        return log_string

arcade_google_docs/tools/edit_agent/planner.py

@@ -0,0 +1,130 @@
+import asyncio
+
+from arcade_tdk.errors import ToolExecutionError
+from openai import OpenAI
+
+from arcade_google_docs.docmd import DocMD
+from arcade_google_docs.tools.edit_agent.models.planning import (
+    Plan,
+    ReasoningEffort,
+    Step,
+)
+from arcade_google_docs.tools.edit_agent.progress_tracker import ExecutionProgressTracker
+from arcade_google_docs.tools.edit_agent.prompts import PLAN_EDIT_DOCUMENT_SYSTEM_PROMPT
+
+
+async def _generate_step_for_user_edit_request(
+    openai_client: OpenAI,
+    docmd: DocMD,
+    user_edit_request: str,
+    query_index: int,
+    reasoning_effort: ReasoningEffort,
+    progress: ExecutionProgressTracker,
+) -> Step:
+    """Generate a step for a single user edit request."""
+    messages = [
+        {"role": "developer", "content": PLAN_EDIT_DOCUMENT_SYSTEM_PROMPT},
+        {
+            "role": "user",
+            "content": f"{docmd}\n\nEDIT REQUEST:\n{user_edit_request}",
+        },
+    ]
+
+    try:
+        completion = await asyncio.get_event_loop().run_in_executor(
+            None,
+            lambda: openai_client.beta.chat.completions.parse(
+                model="gpt-5-mini",
+                messages=messages,  # type: ignore[arg-type]
+                response_format=Step,
+                reasoning_effort=reasoning_effort.value,  # type: ignore[arg-type]
+            ),
+        )
+        step = completion.choices[0].message.parsed
+    except Exception as e:
+        progress.add(
+            f"Failed to generate step for edit request {query_index + 1} '{user_edit_request}': {e}"
+        )
+        raise ToolExecutionError(
+            message=(
+                f"Failed to generate step for edit request {query_index + 1} '{user_edit_request}'"
+            ),
+            developer_message="\n".join(progress.get_messages()),
+        )
+    else:
+        return step or Step(edit_items=[])
+
+
+def _merge_steps(steps: list[Step]) -> Step:
+    """Merge multiple steps into a single step."""
+    merged_edit_items = []
+
+    for step in steps:
+        merged_edit_items.extend(step.edit_items)
+
+    return Step(edit_items=merged_edit_items)
+
+
+def _build_ordered_plan(merged_step: Step) -> Plan:
+    """
+    Convert a merged step into an ordered plan with content edits first,
+    then all formatting/styling edits grouped into a single step at the end.
+    """
+    if not merged_step.edit_items:
+        return Plan(steps=[])
+
+    content_edits = []
+    formatting_edits = []
+
+    for i, edit_item in enumerate(merged_step.edit_items):
+        if edit_item.edit_request_type.is_style_or_formatting_edit():
+            formatting_edits.append((i, edit_item))
+        else:
+            content_edits.append((i, edit_item))
+
+    # Sort content edits by precedence, maintaining original order for same precedence
+    content_edits.sort(key=lambda x: (x[1].edit_request_type.get_precedence(), x[0]))
+
+    steps = []
+
+    for _, edit_item in content_edits:
+        step = Step(edit_items=[edit_item])
+        steps.append(step)
+
+    if formatting_edits:
+        formatting_items = [edit_item for _, edit_item in formatting_edits]
+        formatting_step = Step(edit_items=formatting_items)
+        steps.append(formatting_step)
+
+    return Plan(steps=steps)
+
+
+async def plan_edits(
+    openai_client: OpenAI,
+    docmd: DocMD,
+    user_edit_requests: list[str],
+    reasoning_effort: ReasoningEffort,
+    progress: ExecutionProgressTracker,
+) -> Plan:
+    """
+    Plan edits to a Google Docs document before actually executing them.
+    Returns a plan with ordered steps for executing the edits.
+    """
+    # Generate a step for each user edit request in parallel
+    step_tasks = [
+        _generate_step_for_user_edit_request(
+            openai_client,
+            docmd,
+            user_edit_request,
+            i,
+            reasoning_effort,
+            progress,
+        )
+        for i, user_edit_request in enumerate(user_edit_requests)
+    ]
+    steps = await asyncio.gather(*step_tasks)
+
+    merged_step = _merge_steps(steps)
+    plan = _build_ordered_plan(merged_step)
+
+    return plan

arcade_google_docs/tools/edit_agent/progress_tracker.py

@@ -0,0 +1,32 @@
+class ExecutionProgressTracker:
+    """Helper class to track execution progress throughout the edit process."""
+
+    def __init__(self) -> None:
+        self.messages: list[str] = []
+
+    def add(self, message: str) -> None:
+        """Add a progress message."""
+        self.messages.append(message)
+
+    def add_step_start(self, step_num: int, total_steps: int) -> None:
+        """Add a step start message."""
+        self.add(f"Executing step {step_num + 1} of {total_steps}")
+
+    def add_step_success(self, step_num: int, total_steps: int) -> None:
+        """Add a step success message."""
+        self.add(f"Successfully performed the edits for step {step_num + 1} of {total_steps}")
+
+    def add_step_error(self, step_num: int, total_steps: int, error: Exception) -> None:
+        """Add a step error message."""
+        message = (
+            f"I encountered an error while executing step {step_num + 1} of {total_steps}: {error}"
+        )
+        self.add(message)
+
+    def add_step_retry(self, step_num: int, total_steps: int) -> None:
+        """Add a step retry message."""
+        self.add(f"I will retry step {step_num + 1} of {total_steps}")
+
+    def get_messages(self) -> list[str]:
+        """Get all progress messages."""
+        return self.messages.copy()

arcade_google_docs/tools/edit_agent/prompts.py

@@ -0,0 +1,204 @@
+PLAN_EDIT_DOCUMENT_SYSTEM_PROMPT = """
+Your purpose is to understand the provided document and THE SINGLE QUERY to create a minimal list of edits.
+
+UNDERSTANDING STYLE NOTATION IN DOCMD:
+Blocks may have a 'styles' attribute showing text formatting (e.g., styles=bold:0-11,italic:15-20).
+The format is: style_name:start-end (positions relative to block start).
+Common styles: bold, italic, underline, strikethrough, color=rgb(r,g,b), bgColor=rgb(r,g,b), fontSize=Xpt, font=Name.
+
+CRITICAL RULES:
+1. ONLY address the ONE query provided - do not generate edits for anything else
+2. Check if the requested change already exists in the document before creating an edit
+3. Return an EMPTY list if the change already exists or is not needed
+4. Be MINIMAL - only create the exact edits required for the single query
+5. STYLE INHERITANCE WARNING: When using replaceAllText, the replacement text inherits the style of the text being replaced.
+   - If the original text is bold, the replacement will be bold
+   - To avoid unwanted style inheritance, prefer insertText at specific positions when adding new content
+   - Only use replaceAllText when you want to preserve existing styles or when replacing all instances
+6. Do NOT duplicate edits or create variations of the same edit
+
+You should generate a flat list of edit requests needed to satisfy ONLY THE SINGLE QUERY provided.
+The system will handle ordering and dependencies automatically.
+
+Each edit request should be atomic and focused on a single change.
+Break down complex operations into their individual components.
+
+IMPORTANT: A 'query' is a natural language description of a change.
+- A single query can result in MULTIPLE edit requests (e.g., "make the title bold and centered" needs 2 edits)
+- A query can also result in ZERO edit requests if the requested change already exists in the document
+- Only include edit requests that are actually needed based on the current document state
+- NEVER generate edits that weren't explicitly requested in the query
+
+IMPORTANT CONSTRAINTS:
+- Location Constraints: Some operations can't be used in certain locations (e.g., insertText can't be used at table start indices, must use preceding paragraph)
+- Segment Constraints: Many operations are restricted to body-only (segment ID must be empty) like insertSectionBreak and insertPageBreak
+- Cascading Effects: deleteContentRange across paragraph boundaries will merge paragraphs, potentially affecting subsequent paragraph-level operations
+
+
+FOR EACH EDIT REQUEST: Include specific thoughts that explain why this particular edit is needed and how it addresses the query.
+These thoughts should be specific to each individual edit, not general thoughts about the overall plan.
+
+- replaceAllText: Use when you need to find and replace all occurrences of specific text or regex patterns throughout the entire document (or specified tabs) with support for case-sensitive/insensitive matching. Do not use when you need to replace text at a specific location/range only, or when you need to selectively replace some instances while preserving others. Replacing more text than necessary will result in unintentional styling being applied to the replacement text.
+
+- insertText: Use this to add new text at a specific index within an existing paragraph or append text to the end of a document/header/footer/footnote segment, with automatic style inheritance from neighboring text. Do not use this at table start indices (insert in the preceding paragraph instead) or for replacing existing text (use replaceAllText or replaceNamedRangeContent instead).
+
+- updateTextStyle: Use to modify text formatting properties (bold, italic, underline, colors, fonts, links, etc.) for existing text within a specified range, including updating bullet formatting when the range contains list paragraphs. Do not use for paragraph-level formatting (alignment, spacing, borders) which requires updateParagraphStyle, or when inserting new text where insertText should be used instead.
+
+- createParagraphBullets: Use this to apply bullet or numbered list formatting to existing paragraphs within a specified range, with nesting levels automatically determined by leading tabs. Do not use this if the paragraphs already have bullets (must delete first with deleteParagraphBullets) or if you need custom bullet styles beyond the available presets.
+
+- deleteParagraphBullets: Use this to remove bullet points or numbering from paragraphs within a specified range while preserving their visual indentation/nesting level. Don't use this if you want to remove both bullets AND indentation, or if you want to change bullet styles rather than remove them entirely (use createParagraphBullets instead).
+
+- updateParagraphStyle: Use to modify paragraph-level formatting properties (alignment, line spacing, indentation, borders, shading, page breaks) for all paragraphs overlapping a specified range; do not use for character-level text styling (bold, italic, fonts) which requires updateTextStyle, or for bullet/list creation which requires createParagraphBullets.
+
+- deleteContentRange: Use when removing any range of text/content from the document body (including across paragraph boundaries which will merge paragraphs), but not for deleting specific structural elements like tables, headers, footers, or positioned objects which have their own dedicated delete operations.
+
+- insertTable: Use when creating a new empty table with specified rows and columns at a document location; don't use when modifying existing tables or populating table content (use updateTable* or insertTableRow/Column requests instead).
+
+- insertTableRow: Use when adding empty rows to an existing table at a specific position (above or below a reference cell); do not use for creating new tables (use insertTable) or when you need rows with pre-populated content (insert empty row first, then add content separately).
+
+- insertTableColumn: Use when adding a new empty column to an existing table at a specific position (left or right of a reference cell); do not use when creating a new table initially (use insertTable instead) or when modifying properties of existing columns (use updateTableColumnProperties).
+
+- deleteTableRow: Use when you need to remove an entire row from an existing table by providing a reference to any cell within that row (via tableCellLocation with tableStartLocation, rowIndex, and columnIndex); do not use when you want to delete only the content within cells while preserving the row structure, delete individual cells, or remove the entire table.
+
+- deleteTableColumn: Use when you need to remove an entire column from an existing table by specifying any cell location within that column (via tableCellLocation with tableStartLocation, rowIndex, and columnIndex); do not use when you only want to clear cell contents without removing the column structure, need to delete rows instead of columns, or want to delete the entire table.
+
+- insertPageBreak: Use to force content to start on a new page within the document body at a specific paragraph index or at the end of the body; do not use when the target location is inside a table, equation, footnote, header, or footer (segment ID must be empty/body only).
+
+- updateTableColumnProperties: Use this to modify the width properties of existing table columns (setting fixed widths or evenly distributed widths), but not for adding/removing columns, changing cell content, or modifying cell styles/borders which require different request types.
+
+- updateTableCellStyle: Use this to modify visual styling properties of table cells (backgroundColor, borders, padding, contentAlignment) for a specific range of cells or an entire table; do NOT use this for changing table structure (adding/removing rows/columns), modifying cell content, or updating table/row-level properties (use updateTableRowStyle or updateTableColumnProperties instead).
+
+- updateTableRowStyle: Use when you need to modify row-level properties of an existing table (minimum height, header designation, or page-break prevention for specific rows or all rows); don't use when you need to modify cell content, cell styling, column properties, or create/delete rows.
+
+- updateDocumentStyle: Use this to modify document-wide properties like page margins, page size, background color, page numbering, and header/footer settings that apply to the entire document or tab; don't use this for styling specific text, paragraphs, or individual sections within the document (use updateTextStyle, updateParagraphStyle, or updateSectionStyle instead).
+
+- mergeTableCells: Use to combine multiple adjacent table cells into a single cell (with text concatenated into the upper-left/head cell), don't use when cells are already merged or when you need to unmerge existing merged cells (use unmergeTableCells instead).
+
+- unmergeTableCells: Use this to separate previously merged table cells back into individual cells (with text preserved in the head cell), don't use this if the specified cells aren't already merged or if you want to keep the cells merged together.
+
+- updateSectionStyle: Use to modify section-level formatting properties like margins, columns, page orientation, and header/footer behavior for specific document sections (body only); don't use for paragraph/text-level styling, document-wide styles, or content within headers/footers/footnotes.
+
+- insertSectionBreak: Use when creating document sections with different formatting properties (headers/footers, margins, page orientation, or column layouts) by inserting CONTINUOUS or NEXT_PAGE section breaks in the document body; do NOT use inside tables, equations, footnotes, headers, or footers, or when a simple page break suffices (use insertPageBreak instead).
+
+- pinTableHeaderRows: Use when you need table header rows to repeat at the top of each page in multi-page tables (setting pinnedHeaderRowsCount > 0) or to remove existing pinned headers (setting to 0); don't use for tables that fit on a single page or when you want different headers on different pages.
+
+---
+
+All messages sent to you will be in the following format:
+{a document in DocMD format}
+EDIT REQUEST:
+{a single natural language edit request that describes a desired change to the document}
+"""  # noqa: E501
+
+DETERMINE_BLOCK_ID_SYSTEM_PROMPT = """
+Your purpose is to understand the provided document and user edit request to
+determine the block id that the edit request is targeting. The block id is a
+unique identifier for a block in the document. A block id is a string that is
+constructed from a block type and a counter. For example, the first paragraph
+block would have the id "P1", the second paragraph block would have the id "P2",
+and so on. In docMD, the block id is the first element in the block's metadata.
+
+All messages sent you will be in the following format:
+{a document in DocMD format}
+
+EDIT REQUEST:
+{a natural language edit request}
+"""
+
+GENERATE_EDIT_REQUEST_SYSTEM_PROMPT = """
+Your purpose is to understand the provided document and edit instructions to
+create an EditRequest object that satisfies the edit instructions.
+The EditRequest that you return will be used to
+construct a batchUpdate request to the Google Docs API. The EditRequest object
+that you are constructing is a part of a larger plan.
+
+UNDERSTANDING STYLE NOTATION IN DOCMD:
+Blocks may have a 'styles' attribute showing text formatting (e.g., styles=bold:0-11,italic:15-20).
+The format is: style_name:start-end (positions relative to block start).
+This helps you understand what text has special formatting.
+
+CRITICAL STYLE INHERITANCE RULES:
+- replaceAllText: Replacement text inherits the style of the matched text
+- insertText: New text inherits style from neighboring text at the insertion point
+- If you need to add text WITHOUT inheriting existing styles, insert at positions without styling
+- If styles show bold:0-11 and you replace text at positions 0-11, the replacement will be bold
+
+For completeness, you may have access to a stream of thoughts that were
+generated when the plan was previously created.
+You should treat these thoughts as supplemental information to aide in your
+understanding of why you are being asked to construct the single and narrow
+EditRequest.
+
+All messages sent you will be in the following format:
+
+DOCUMENT:
+{a document in DocMD format}
+
+THOUGHTS THAT OCCURRED WHEN CONSTRUCTING YOUR INSTRUCTIONS:
+{a list of thoughts that were generated when the following instructions were created}
+
+
+YOUR JOB AND SOLE PURPOSE IS TO CONSTRUCT A SINGLE EDIT REQUEST OBJECT THAT SATISFIES
+THE FOLLOWING INSTRUCTIONS:
+{edit instructions}
+"""
+
+GENERATE_EDIT_REQUEST_SYSTEM_PROMPT_WITH_LOCATION_TAGS = """
+Your purpose is to understand the provided document and edit instructions to
+create an EditRequest object that satisfies the edit instructions.
+The EditRequest that you return will be used to
+construct a batchUpdate request to the Google Docs API. The EditRequest object
+that you are constructing is a part of a larger plan. You will also be provided
+with a location tag on each word in the block that that the edit might be targeting.
+It is possible that the edit request is targeting a block that is not the one that
+the location tags are on, but instead the block before or after.
+The location tag is a string in the format <@start_index>word</@end_index>.
+
+UNDERSTANDING STYLE NOTATION IN DOCMD:
+Blocks may have a 'styles' attribute showing text formatting (e.g., styles=bold:0-11,italic:15-20).
+The format is: style_name:start-end (positions relative to block start).
+This helps you understand what text has special formatting.
+
+CRITICAL STYLE INHERITANCE RULES:
+- replaceAllText: Replacement text inherits the style of the matched text
+- insertText: New text inherits style from neighboring text at the insertion point
+- If you need to add text WITHOUT inheriting existing styles, insert at positions without styling
+- If styles show bold:0-11 and you replace text at positions 0-11, the replacement will be bold
+
+For completeness, you may have access to a stream of thoughts that were
+generated when the plan was previously created.
+You should treat these thoughts as supplemental information to aide in your
+understanding of why you are being asked to construct the single and narrow
+EditRequest.
+
+All messages sent you will be in the following format:
+
+DOCUMENT:
+{a document in DocMD format}
+
+THOUGHTS THAT OCCURRED WHEN CONSTRUCTING YOUR INSTRUCTIONS:
+{a list of thoughts that were generated when the following instructions were created}
+
+
+YOUR JOB AND SOLE PURPOSE IS TO CONSTRUCT A SINGLE EDIT REQUEST OBJECT THAT SATISFIES
+THE FOLLOWING INSTRUCTIONS:
+{edit instructions}
+"""
+
+ERROR_FEEDBACK_PROMPT = """
+The previous attempt to execute these requests failed with the following error:
+
+Error details:
+{error}
+
+Previous generated requests that failed:
+{failed_requests}
+
+Please regenerate the request, taking into account the error above. The error may indicate:
+- Invalid field values or formatting
+- Incorrect indices or ranges
+- Missing required fields
+- Structural issues with the request
+
+Adjust your response to fix the issue indicated by the error.
+"""