aria-code 0.167.0__py3-none-win_amd64.whl

aria_code/providers/tool_messages.py

@@ -0,0 +1,100 @@
+"""Make the agent loop's tool rounds acceptable to OpenAI-style and plain chat APIs.
+
+The agent loop records a tool round the way Ollama takes it: an assistant
+message whose ``tool_calls`` have no ``id`` and dict ``arguments``, then
+``role: "tool"`` messages with no ``tool_call_id``. Ollama accepts that.
+OpenAI-compatible APIs do not — Vertex AI answered "Expected input to contain
+field: 'id'", OpenAI refuses a tool message that answers no call — and the
+registry providers sent only role and content, so a ``tool`` message reached
+OpenAI with no id and Anthropic with a role it does not have. Either way a
+task stopped after its first tool round: the file was written, the tests were
+never run.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Iterable
+
+
+def _arguments(value) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value if value is not None else {}, ensure_ascii=False)
+
+
+def to_openai_tool_protocol(messages: Iterable[dict]) -> list[dict]:
+    """Native tool turns with ids: every call answered, every answer tied to a call."""
+    out: list[dict] = []
+    pending: list[tuple[str, str]] = []          # (id, name) of calls not yet answered
+    counter = 0
+
+    def answer_the_rest() -> None:
+        for call_id, name in pending:
+            out.append({"role": "tool", "tool_call_id": call_id,
+                        "content": f"({name} returned no result)"})
+        pending.clear()
+
+    for message in messages:
+        message = dict(message)
+        role = message.get("role")
+        if role == "tool":
+            name = str(message.pop("name", "") or "")
+            call_id = message.get("tool_call_id")
+            match = next((p for p in pending if p[0] == call_id), None) if call_id else None
+            match = match or next((p for p in pending if p[1] == name), None) or (pending[0] if pending else None)
+            if match is None:
+                # An answer to no call: keep what it says, as ordinary text.
+                out.append({"role": "user", "content": f"Result of {name or 'a tool'}:\n{message.get('content', '')}"})
+                continue
+            pending.remove(match)
+            out.append({"role": "tool", "tool_call_id": match[0], "content": str(message.get("content", ""))})
+            continue
+        answer_the_rest()
+        calls = message.get("tool_calls")
+        if role == "assistant" and calls:
+            fixed = []
+            for call in calls:
+                function = dict(call.get("function") or {})
+                name = str(function.get("name") or call.get("name") or "")
+                if not name:
+                    continue
+                counter += 1
+                call_id = str(call.get("id") or f"call_{counter}")
+                fixed.append({"id": call_id, "type": "function",
+                              "function": {"name": name, "arguments": _arguments(function.get("arguments"))}})
+                pending.append((call_id, name))
+            message["tool_calls"] = fixed
+            if not fixed:
+                message.pop("tool_calls")
+            if message.get("content") is None:
+                message["content"] = ""
+        out.append(message)
+    answer_the_rest()
+    return out
+
+
+def flatten_tool_turns(messages: Iterable[dict]) -> list[dict]:
+    """Tool rounds as plain conversation, for APIs reached without native tool history.
+
+    Calls become a line in the assistant's message and results become user
+    text; consecutive messages of one role are merged, since some APIs insist
+    that user and assistant alternate.
+    """
+    out: list[dict] = []
+    for message in messages:
+        role = message.get("role")
+        content = str(message.get("content") or "")
+        if role == "tool":
+            role, content = "user", f"Result of {message.get('name') or 'a tool'}:\n{content}"
+        elif role == "assistant" and message.get("tool_calls"):
+            lines = [content] if content.strip() else []
+            for call in message["tool_calls"]:
+                function = call.get("function") or {}
+                lines.append(f"[called {function.get('name', '?')} with {_arguments(function.get('arguments'))}]")
+            content = "\n".join(lines)
+        if out and out[-1]["role"] == role and role in ("user", "assistant"):
+            out[-1]["content"] += "\n\n" + content
+        else:
+            out.append({"role": role, "content": content})
+    return out

aria_code/realty_data_tools.py

@@ -0,0 +1,4 @@
+"""Compatibility import for :mod:`tools.realty_data_tools`."""
+from importlib import import_module as _import_module
+import sys as _sys
+_sys.modules[__name__] = _import_module("tools.realty_data_tools")

aria_code/report_exporters.py

@@ -0,0 +1,150 @@
+"""report_exporters.py — Markdown → Word (.docx) / PowerPoint (.pptx) export.
+
+Complements markdown_pdf.py (Markdown → PDF): same input, different output
+formats, for callers who need an editable document instead of print output.
+
+Parsing approach: run the input through the `markdown` library (already a
+core dependency) to get real HTML, then walk that with BeautifulSoup (already
+a "files"-extra dependency, used elsewhere for document parsing) to pull out
+a flat sequence of (heading-level | paragraph | bullet) blocks. This only
+covers the markdown subset aria-code's own report generators actually emit
+(headings, paragraphs, bullet/numbered lists, bold/italic inline) — it is not
+a full CommonMark-to-OOXML converter, and unsupported constructs (tables,
+images, nested blockquotes) are dropped rather than mis-rendered.
+
+Public API:
+    markdown_to_docx(md_text_or_path, docx_path, title=None) -> Optional[Path]
+    markdown_to_pptx(md_text_or_path, pptx_path, title=None) -> Optional[Path]
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+logger = logging.getLogger(__name__)
+
+
+def _read_md(md_text_or_path: Union[str, Path]) -> str:
+    if isinstance(md_text_or_path, Path) or (
+        isinstance(md_text_or_path, str) and len(md_text_or_path) < 260 and Path(md_text_or_path).exists()
+    ):
+        return Path(md_text_or_path).read_text(encoding="utf-8")
+    return str(md_text_or_path)
+
+
+def _parse_blocks(md_text: str) -> List[Dict[str, Any]]:
+    """Return a flat list of {"type": "heading"|"para"|"bullet", "level": int, "text": str}."""
+    import markdown as _markdown
+    from bs4 import BeautifulSoup
+
+    html = _markdown.markdown(md_text, extensions=["extra"])
+    soup = BeautifulSoup(html, "html.parser")
+
+    blocks: List[Dict[str, Any]] = []
+    for el in soup.find_all(["h1", "h2", "h3", "h4", "p", "ul", "ol"], recursive=False):
+        if el.name in ("h1", "h2", "h3", "h4"):
+            text = el.get_text(strip=True)
+            if text:
+                blocks.append({"type": "heading", "level": int(el.name[1]), "text": text})
+        elif el.name == "p":
+            text = el.get_text(strip=True)
+            if text:
+                blocks.append({"type": "para", "text": text})
+        elif el.name in ("ul", "ol"):
+            for li in el.find_all("li", recursive=False):
+                text = li.get_text(strip=True)
+                if text:
+                    blocks.append({"type": "bullet", "text": text})
+    return blocks
+
+
+def markdown_to_docx(
+    md_text_or_path: Union[str, Path],
+    docx_path: Union[str, Path],
+    title: Optional[str] = None,
+) -> Optional[Path]:
+    """Render Markdown to a Word document. Returns the output path, or None on failure."""
+    try:
+        from docx import Document
+        from docx.shared import Pt
+    except ImportError:
+        logger.warning("python-docx not installed — pip install python-docx")
+        return None
+
+    md_text = _read_md(md_text_or_path)
+    blocks = _parse_blocks(md_text)
+    docx_path = Path(docx_path)
+
+    doc = Document()
+    if title:
+        doc.add_heading(title, level=0)
+
+    heading_styles = {1: "Heading 1", 2: "Heading 2", 3: "Heading 3", 4: "Heading 4"}
+    for block in blocks:
+        if block["type"] == "heading":
+            doc.add_heading(block["text"], level=min(block["level"], 4))
+        elif block["type"] == "bullet":
+            doc.add_paragraph(block["text"], style="List Bullet")
+        else:
+            p = doc.add_paragraph(block["text"])
+            p.paragraph_format.space_after = Pt(8)
+
+    docx_path.parent.mkdir(parents=True, exist_ok=True)
+    doc.save(str(docx_path))
+    return docx_path
+
+
+def markdown_to_pptx(
+    md_text_or_path: Union[str, Path],
+    pptx_path: Union[str, Path],
+    title: Optional[str] = None,
+) -> Optional[Path]:
+    """Render Markdown to a slide deck: each heading starts a new slide, with
+    following paragraphs/bullets as its body. Returns the output path, or None on failure."""
+    try:
+        from pptx import Presentation
+        from pptx.util import Pt
+    except ImportError:
+        logger.warning("python-pptx not installed — pip install python-pptx")
+        return None
+
+    md_text = _read_md(md_text_or_path)
+    blocks = _parse_blocks(md_text)
+    pptx_path = Path(pptx_path)
+
+    prs = Presentation()
+    title_layout = prs.slide_layouts[0]
+    body_layout = prs.slide_layouts[1]
+
+    if title:
+        slide = prs.slides.add_slide(title_layout)
+        slide.shapes.title.text = title
+
+    current_slide = None
+    current_body = None
+    for block in blocks:
+        if block["type"] == "heading":
+            current_slide = prs.slides.add_slide(body_layout)
+            current_slide.shapes.title.text = block["text"]
+            current_body = current_slide.placeholders[1].text_frame
+            current_body.clear()
+            first_line = True
+        else:
+            if current_slide is None:
+                # Content before the first heading — give it its own slide.
+                current_slide = prs.slides.add_slide(body_layout)
+                current_slide.shapes.title.text = title or "Summary"
+                current_body = current_slide.placeholders[1].text_frame
+                current_body.clear()
+                first_line = True
+            para = current_body.paragraphs[0] if first_line else current_body.add_paragraph()
+            para.text = block["text"]
+            para.level = 1 if block["type"] == "bullet" else 0
+            para.font.size = Pt(16)
+            first_line = False
+
+    pptx_path.parent.mkdir(parents=True, exist_ok=True)
+    prs.save(str(pptx_path))
+    return pptx_path