Precommit lint

Fix comments
Parse error handling
2026-07-21 12:05:23 -04:00 · 2025-09-12 09:58:37 -07:00 · 2025-09-12 09:55:41 -07:00 · 2025-09-12 09:51:20 -07:00 · 2025-09-08 17:45:06 -04:00 · 2025-09-08 09:46:32 -06:00
33 changed files with 9176 additions and 7619 deletions
@@ -19,8 +19,6 @@ jobs:
        uses: actions/checkout@v5

      - uses: pnpm/action-setup@v4
-        with:
-          version: 10

      - name: Setup Node.js
        uses: actions/setup-node@v4
@@ -1,4 +1,4 @@
-name: Lint - Python
+name: Lint

 on:
  push:
@@ -29,7 +29,18 @@ jobs:
      - name: Set up Python
        run: uv python install ${{ matrix.python-version }}

+      - uses: pnpm/action-setup@v4
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version-file: "ts/llama_cloud_services/.nvmrc"
+      - name: Install dependencies
+        run: pnpm install --no-frozen-lockfile
+
      - name: Run linter
        shell: bash
        working-directory: py
        run: uv run -- pre-commit run -a
+      # the js checks are run roundaboutly through lint-staged, and -a doesn't run it. Run them directly.
+      - run: pnpm -w --filter llama-cloud-services run lint
+      - run: pnpm -w --filter llama-cloud-services run format:check
@@ -1,37 +0,0 @@
-name: Lint - TypeScript
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "ts/**"
-  pull_request:
-    paths:
-      - "ts/**"
-
-env:
-  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
-  TURBO_TEAM: ${{ vars.TURBO_TEAM }}
-  TURBO_REMOTE_ONLY: true
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: pnpm/action-setup@v4
-        with:
-          version: 10
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: "ts/llama_cloud_services/.nvmrc"
-      - name: Install dependencies
-        run: pnpm install --no-frozen-lockfile
-      - name: Run lint
-        working-directory: ts/llama_cloud_services/
-        run: pnpm run lint
-      - name: Run Prettier
-        working-directory: ts/llama_cloud_services/
-        run: pnpm run format
@@ -13,8 +13,6 @@ jobs:
        uses: actions/checkout@v5

      - uses: pnpm/action-setup@v4
-        with:
-          version: 10

      - name: Setup Node.js
        uses: actions/setup-node@v4
@@ -49,6 +47,6 @@ jobs:
        uses: ncipollo/release-action@v1
        with:
          artifacts: "ts/llama_cloud_services/llama-cloud-services*.tgz"
-          name: Release ${{ github.ref }} - LlamaCloud Services TS
-          bodyFile: "ts/llama_cloud_services/CHANGELOG.md"
+          name: Release ${{ github.ref_name }} - LlamaCloud Services TS
+          generateReleaseNotes: true
          token: ${{ secrets.GITHUB_TOKEN }}
@@ -1,4 +1,4 @@
-name: Lint - TypeScript
+name: Test - TypeScript

 on:
  push:
@@ -23,17 +23,14 @@ jobs:
    steps:
      - uses: actions/checkout@v5
      - uses: pnpm/action-setup@v4
-        with:
-          version: 10
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version-file: "ts/llama_cloud_services/.nvmrc"
      - name: Install dependencies
-        run: pnpm install --no-frozen-lockfile
-      - name: Run Build
-        working-directory: ts/llama_cloud_services/
-        run: pnpm build
+        run: pnpm -r install --no-frozen-lockfile
+      - name: Build package
+        run: pnpm --filter llama-cloud-services build
      - name: Run Tests
        working-directory: ts/llama_cloud_services/
        run: pnpm test
@@ -60,11 +60,13 @@ repos:
        additional_dependencies: [black==23.10.1]
        # Using PEP 8's line length in docs prevents excess left/right scrolling
        args: [--line-length=79]
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.0.3
+  - repo: local
    hooks:
-      - id: prettier
-        exclude: ^(uv.lock|ts/llama_cloud_services/pnpm-lock.yaml|ts/e2e-tests)
+      - id: lint-staged
+        name: Run lint-staged for TS files
+        entry: pnpm -w exec lint-staged
+        language: system
+        pass_filenames: false
  - repo: https://github.com/codespell-project/codespell
    rev: v2.2.6
    hooks:
@@ -9,7 +9,6 @@ This repository contains the code for hand-written SDKs and clients for interact
 This includes:

 - [LlamaParse](./parse.md) - A GenAI-native document parser that can parse complex document data for any downstream LLM use case (Agents, RAG, data processing, etc.).
- [LlamaReport (beta/invite-only)](./report.md) - A prebuilt agentic report builder that can be used to build reports from a variety of data sources.
 - [LlamaExtract](./extract.md) - A prebuilt agentic data extractor that can be used to transform data into a structured JSON representation.
 - [LlamaCloud Index](./index.md) - A widely customizable and fully automated document ingestion pipeline that also serves retrieval purposes.

@@ -28,13 +27,11 @@ Then, you can use the services in your code:
 ```python
 from llama_cloud_services import (
    LlamaParse,
-    LlamaReport,
    LlamaExtract,
    LlamaCloudIndex,
 )

 parser = LlamaParse(api_key="YOUR_API_KEY")
-report = LlamaReport(api_key="YOUR_API_KEY")
 extract = LlamaExtract(api_key="YOUR_API_KEY")
 index = LlamaCloudIndex(
    "my_first_index", project_name="default", api_key="YOUR_API_KEY"
@@ -44,7 +41,6 @@ index = LlamaCloudIndex(
 See the quickstart guides for each service for more information:

 - [LlamaParse](./parse.md)
- [LlamaReport (beta/invite-only)](./report.md)
 - [LlamaExtract](./extract.md)
 - [LlamaCloud Index](./index.md)

@@ -57,13 +53,11 @@ You can also create your API key in the EU region [here](https://cloud.eu.llamai
 ```python
 from llama_cloud_services import (
    LlamaParse,
-    LlamaReport,
    LlamaExtract,
    EU_BASE_URL,
 )

 parser = LlamaParse(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
-report = LlamaReport(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
 extract = LlamaExtract(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
 index = LlamaCloudIndex(
    "my_first_index",
@@ -4,7 +4,6 @@ In this folder you will find several python notebooks that contain examples rega

 - [LlamaParse](./parse/)
 - [LlamaExtract](./extract/)
- [LlamaReport](./report/)
 - [LlamaCloudIndex](./index/)

 Follow the instructions in each notebook to get started!
@@ -1,762 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Report Generation with LlamaReport\n",
-    "\n",
-    "In this notebook, we'll walk through the basic process of generating a report with LlamaReport, and highlight some of the key features of the library.\n",
-    "\n",
-    "TLDR:\n",
-    "1. Download source data to use as knowledge base for the report\n",
-    "2. Kick off report generation with a template\n",
-    "3. Get the plan and review/accept/reject suggestions\n",
-    "4. Get the final report\n",
-    "5. Review/accept/reject suggestions to edit the final report\n",
-    "6. Print the final report"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install llama-cloud-services"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Download Source Data\n",
-    "\n",
-    "Here, we download the `Attention is All You Need` paper as a PDF.\n",
-    "\n",
-    "LlamaReport currently supports up to 5 files as input, and essentially any file type that can be parsed by LlamaParse.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "!wget \"https://arxiv.org/pdf/1706.03762.pdf\" -O \"./attention.pdf\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Kick off Report Generation\n",
-    "\n",
-    "Here, we kick off report generation with a template.\n",
-    "\n",
-    "The template can either be a string or a file path, but here we'll use a string.\n",
-    "\n",
-    "In our experiments, anything works as a template, but some general guidelines:\n",
-    "\n",
-    "- Use markdown formatting + instructions in each section to guide the report generation\n",
-    "- If using an existing file as a template, provide extra instructions to guide the report generation\n",
-    "\n",
-    "**NOTE:** Since we are in a notebook, we will use async functions and `await` throughout. Synchronous methods that work without `await` are available by just removing the `a` from the method name and removing the `await` keyword."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from llama_cloud_services import LlamaReport\n",
-    "\n",
-    "llama_report = LlamaReport(\n",
-    "    api_key=\"llx-...\",\n",
-    ")\n",
-    "\n",
-    "report_client = await llama_report.acreate_report(\n",
-    "    name=\"my_cool_report_on_attention\",\n",
-    "    # can pass in file paths or bytes\n",
-    "    input_files=[\"./attention.pdf\"],\n",
-    "    template_text=\"\"\"\\\n",
-    "# [Some title]\\n\\n\n",
-    "## TLDR\\n\n",
-    "A quick summary of the paper.\\n\\n\n",
-    "## Details\\n\n",
-    "More details about the paper, possibly more than one section here.\\n\n",
-    "\"\"\",\n",
-    "    # optional additional instructions for the report generation\n",
-    "    # template_instructions=None,\n",
-    "    # optional file path to an existing template instead of template_text\n",
-    "    # template_file=None,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The returned `ReportClient` object is used to interact with the report generation process for this specific report."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Report(id=0a394b33-1a3e-463c-b5cb-7ff8ab827d0a, name=my_cool_report_on_attention)\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(report_client)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Get the plan\n",
-    "\n",
-    "The first phases of report generation involve ingesting the source data and generating a plan.\n",
-    "\n",
-    "The plan is a list of instructions for the report generation, and can be reviewed/accepted/rejected by the user.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "plan = await report_client.await_for_plan(\n",
-    "    timeout=10000,\n",
-    "    poll_interval=10,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "# {title}\n",
-      "[ReportQuery(field='title', prompt='Generate a clear and concise title for this paper about the Transformer model and attention mechanisms', context='The paper discusses the Transformer architecture for sequence transduction using attention mechanisms, focusing on machine translation applications')]\n",
-      "==================\n",
-      "## TLDR\n",
-      "\n",
-      "{tldr_content}\n",
-      "[ReportQuery(field='tldr_content', prompt='Write a brief, clear summary of the key points about the Transformer model', context='Focus on the main innovations: attention mechanisms, efficiency improvements, and state-of-the-art results in machine translation')]\n",
-      "==================\n",
-      "## Details\n",
-      "\n",
-      "{details_content}\n",
-      "[ReportQuery(field='details_content', prompt='Provide detailed information about the Transformer model architecture and its applications', context='Include information about:\\n- The attention mechanism implementation\\n- Advantages over recurrent and convolutional models\\n- Performance in machine translation tasks\\n- Training efficiency improvements')]\n",
-      "==================\n"
-     ]
-    }
-   ],
-   "source": [
-    "for plan_block in plan.blocks:\n",
-    "    print(plan_block.block.template)\n",
-    "    print(plan_block.queries)\n",
-    "    print(\"==================\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With the plan, we can either use it to kick off generation of the final report, or we can edit the plan and adjust it as needed.\n",
-    "\n",
-    "While we could manually edit the objects here and use `await report_client.aupdate_plan(action=\"edit\", updated_plan=plan)`, we can also use `LlamaReport` to agentically edit the plan."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "suggestions = await report_client.asuggest_edits(\n",
-    "    \"Can you split the details section into two sections?\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Justification for change: \n",
-      "I'll help you break down the details section into two distinct parts - one focusing on the architecture and another on the practical applications and performance. This will make the content more organized and easier to follow. The original block at index 2 will be replaced with these two new sections.\n",
-      "\n",
-      "Proposed changes:\n",
-      "\n",
-      "## Architecture Details\n",
-      "\n",
-      "{architecture_content}\n",
-      "\n",
-      "[ReportQuery(field='architecture_content', prompt='Describe the technical details of the Transformer model architecture', context='Focus on:\\n- Core components of the Transformer architecture\\n- Self-attention mechanism implementation\\n- Multi-head attention details\\n- Position encoding approach\\n- Feed-forward network structure')]\n",
-      "==================\n",
-      "\n",
-      "## Performance and Applications\n",
-      "\n",
-      "{applications_content}\n",
-      "\n",
-      "[ReportQuery(field='applications_content', prompt='Explain the practical applications and performance advantages of the Transformer model', context='Cover:\\n- Comparison with RNN and CNN models\\n- Machine translation results and benchmarks\\n- Training efficiency improvements\\n- Real-world applications and use cases\\n- Scalability benefits')]\n",
-      "==================\n"
-     ]
-    }
-   ],
-   "source": [
-    "for suggestion in suggestions:\n",
-    "    print(\"Justification for change:\", suggestion.justification)\n",
-    "    print(\"Proposed changes:\")\n",
-    "    for plan_block in suggestion.blocks:\n",
-    "        print(plan_block.block.template)\n",
-    "        print(plan_block.queries)\n",
-    "        print(\"==================\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "This looks pretty good! We can also use the client to automatically accept and apply, or reject, these suggestions.\n",
-    "\n",
-    "This will (locally) keep track of the history of changes, so that future suggestions can be based on the previous changes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for suggestion in suggestions:\n",
-    "    await report_client.aaccept_edit(suggestion)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "What effect did that have on the tracked local history? Let's see!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[EditAction(block_idx=2, old_content='## Details\\n\\n{details_content}\\n\\nField: details_content, Prompt: Provide detailed information about the Transformer model architecture and its applications, Context: Include information about:\\n- The attention mechanism implementation\\n- Advantages over recurrent and convolutional models\\n- Performance in machine translation tasks\\n- Training efficiency improvements\\nDepends on: none', new_content='\\n## Architecture Details\\n\\n{architecture_content}\\n\\n\\nField: architecture_content, Prompt: Describe the technical details of the Transformer model architecture, Context: Focus on:\\n- Core components of the Transformer architecture\\n- Self-attention mechanism implementation\\n- Multi-head attention details\\n- Position encoding approach\\n- Feed-forward network structure\\nDepends on: none', action='approved', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 773558)),\n",
-       " EditAction(block_idx=3, old_content='[No old content]', new_content='\\n## Performance and Applications\\n\\n{applications_content}\\n\\n\\nField: applications_content, Prompt: Explain the practical applications and performance advantages of the Transformer model, Context: Cover:\\n- Comparison with RNN and CNN models\\n- Machine translation results and benchmarks\\n- Training efficiency improvements\\n- Real-world applications and use cases\\n- Scalability benefits\\nDepends on: previous', action='approved', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 773687))]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "report_client.edit_history"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[Message(role=<MessageRole.USER: 'user'>, content='Can you split the details section into two sections?', timestamp=datetime.datetime(2025, 2, 4, 20, 59, 47, 754848)),\n",
-       " Message(role=<MessageRole.ASSISTANT: 'assistant'>, content=\"\\nI'll help you break down the details section into two distinct parts - one focusing on the architecture and another on the practical applications and performance. This will make the content more organized and easier to follow. The original block at index 2 will be replaced with these two new sections.\\n\", timestamp=datetime.datetime(2025, 2, 4, 20, 59, 55, 482070))]"
-      ]
-     },
-     "execution_count": null,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "report_client.chat_history"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "These two items are used to provide context for future suggestions! You can always clear this, or provide your own history."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# report_client.suggest_edits(\"....\", chat_history=[{\"role\": \"user\", \"content\": \"...\"}, ...])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Get the final report\n",
-    "\n",
-    "Now that we have a plan, we can kick off generation of the final report."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# kicks off report generation\n",
-    "await report_client.aupdate_plan(action=\"approve\")\n",
-    "\n",
-    "# waits for report generation to complete\n",
-    "report = await report_client.await_completion(\n",
-    "    timeout=10000,\n",
-    "    poll_interval=10,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "# Attention Is All You Need: A Pure Attention-Based Architecture for Neural Machine Translation\n",
-      "\n",
-      "## TLDR\n",
-      "\n",
-      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
-      "\n",
-      "\n",
-      "## Architecture Details\n",
-      "\n",
-      "The Transformer architecture represents a groundbreaking approach to sequence processing, built entirely on attention mechanisms without recurrence or convolution. Here are its key technical details:\n",
-      "\n",
-      "Core Components:\n",
-      "- Encoder-decoder architecture with stacked self-attention and point-wise feed-forward layers\n",
-      "- Each layer contains two main sub-layers: multi-head self-attention mechanism and position-wise feed-forward network\n",
-      "- Layer normalization and residual connections between sub-layers\n",
-      "- No recurrent or convolutional elements, enabling parallel processing\n",
-      "\n",
-      "Self-Attention Mechanism:\n",
-      "- Processes relationships between all positions in a sequence simultaneously\n",
-      "- Computes attention weights using queries, keys, and values derived from input representations\n",
-      "- Implements scaled dot-product attention to prevent gradient issues with large input dimensions\n",
-      "- Allows direct modeling of dependencies regardless of positional distance\n",
-      "- Uses masking in decoder to prevent leftward information flow and maintain auto-regressive property\n",
-      "\n",
-      "Multi-Head Attention:\n",
-      "- Employs multiple attention heads operating in parallel\n",
-      "- Each head processes information in different representation subspaces\n",
-      "- Three types of attention applications:\n",
-      "  1. Encoder self-attention (all positions attend to each other)\n",
-      "  2. Decoder self-attention (each position attends to previous positions)\n",
-      "  3. Encoder-decoder attention (decoder queries attend to encoder outputs)\n",
-      "- Counteracts reduced resolution from attention averaging through parallel processing\n",
-      "\n",
-      "Position-wise Feed-Forward Network:\n",
-      "- Applied identically to each position separately\n",
-      "- Consists of two linear transformations with ReLU activation\n",
-      "- Structure: FFN(x) = max(0, xW1 + b1)W2 + b2\n",
-      "- Input and output dimensionality: dmodel = 512\n",
-      "- Inner-layer dimensionality: dff = 2048\n",
-      "- Parameters vary between layers but remain constant across positions\n",
-      "\n",
-      "Position Encoding:\n",
-      "- Adds positional information to input embeddings\n",
-      "- Enables the model to consider sequential order without recurrence\n",
-      "- Implements sinusoidal position encodings to allow model to attend to relative positions\n",
-      "- Maintains constant number of operations between any two positions, unlike convolutional approaches\n",
-      "- Allows effective modeling of both local and long-range dependencies\n",
-      "\n",
-      "\n",
-      "\n",
-      "## Performance and Applications\n",
-      "\n",
-      "The Transformer model demonstrates significant performance advantages and practical applications across multiple domains:\n",
-      "\n",
-      "Performance Advantages over RNN/CNN Models:\n",
-      "- Eliminates sequential computation constraints present in RNNs, enabling superior parallelization\n",
-      "- Reduces operations needed for relating distant positions to a constant number, compared to linear/logarithmic scaling in CNNs\n",
-      "- Processes all input and output positions simultaneously through self-attention mechanisms\n",
-      "- Achieves state-of-the-art results while requiring significantly less computational resources\n",
-      "\n",
-      "Machine Translation Benchmarks:\n",
-      "- WMT 2014 English-to-German: 28.4 BLEU score, exceeding previous best results by over 2 BLEU points\n",
-      "- WMT 2014 English-to-French: 41.8 BLEU score (single-model state-of-the-art)\n",
-      "- Surpasses performance of existing model ensembles in translation tasks\n",
-      "\n",
-      "Training Efficiency:\n",
-      "- Requires only 3.5 days of training on eight GPUs for state-of-the-art performance\n",
-      "- Achieves superior results at \"a small fraction of the training costs\" compared to previous models\n",
-      "- Enables significantly faster training through parallel processing of input/output sequences\n",
-      "- Can reach production-quality performance in as little as twelve hours on modern GPU hardware\n",
-      "\n",
-      "Real-world Applications:\n",
-      "- Machine translation systems\n",
-      "- Natural language understanding tasks\n",
-      "- Reading comprehension\n",
-      "- Abstractive summarization\n",
-      "- Text entailment analysis\n",
-      "- Constituency parsing (achieving 92.7 F1 score in semi-supervised settings)\n",
-      "- Adaptable to both large and limited training data scenarios\n",
-      "\n",
-      "Scalability Benefits:\n",
-      "- Highly parallelizable architecture enables efficient scaling across multiple GPUs\n",
-      "- Constant computational complexity for relating any input/output positions\n",
-      "- Effective handling of long-range dependencies in sequences\n",
-      "- Maintains performance quality while scaling to larger datasets and model sizes\n",
-      "- Generalizes well across different tasks and domains without architectural changes\n",
-      "- Supports efficient inference and deployment in production environments\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "report_text = \"\\n\\n\".join([block.template for block in report.blocks])\n",
-    "print(report_text)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Edit the final report\n",
-    "\n",
-    "Now that we have a report, we can edit it.\n",
-    "\n",
-    "We can use the `asuggest_edits` method to get suggestions for edits, and then use the `aaccept_edit`/`areject_edit` methods to apply them.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Justification for change: \n",
-      "I'd suggest changing \"TLDR\" to \"Executive Summary\" which is more appropriate for a professional or academic report. This term is widely used in formal documents and better reflects the nature of this concise overview section while maintaining the same function of providing a quick summary of the key points.\n",
-      "\n",
-      "Proposed changes:\n",
-      "## Executive Summary\n",
-      "\n",
-      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
-      "==================\n"
-     ]
-    }
-   ],
-   "source": [
-    "suggestions = await report_client.asuggest_edits(\n",
-    "    \"Can you change the TLDR header to something more professional?\"\n",
-    ")\n",
-    "for suggestion in suggestions:\n",
-    "    print(\"Justification for change:\", suggestion.justification)\n",
-    "    print(\"Proposed changes:\")\n",
-    "    for block in suggestion.blocks:\n",
-    "        print(block.template)\n",
-    "        print(\"==================\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Changing to \"Executive Summary\" sounds reasonable, lets accept that!\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "for suggestion in suggestions:\n",
-    "    await report_client.aaccept_edit(suggestion)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Print the final report\n",
-    "\n",
-    "Now that we have a report, we can print it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "# Attention Is All You Need: A Pure Attention-Based Architecture for Neural Machine Translation\n",
-      "\n",
-      "## Executive Summary\n",
-      "\n",
-      "The Transformer introduced a revolutionary architecture that relies entirely on attention mechanisms, eliminating the need for recurrence or convolution in sequence processing. Its key innovations include multi-head self-attention for parallel processing of input sequences, scaled dot-product attention for efficient computation, and positional encodings for sequence order awareness. The model achieved breakthrough results in machine translation (28.4 BLEU on English-to-German, 41.8 BLEU on English-to-French) while requiring significantly less training time than previous approaches, training in 3.5 days on 8 GPUs. This architecture demonstrated that attention mechanisms alone are sufficient for state-of-the-art sequence modeling, setting a new direction for natural language processing.\n",
-      "\n",
-      "\n",
-      "## Architecture Details\n",
-      "\n",
-      "The Transformer architecture represents a groundbreaking approach to sequence processing, built entirely on attention mechanisms without recurrence or convolution. Here are its key technical details:\n",
-      "\n",
-      "Core Components:\n",
-      "- Encoder-decoder architecture with stacked self-attention and point-wise feed-forward layers\n",
-      "- Each layer contains two main sub-layers: multi-head self-attention mechanism and position-wise feed-forward network\n",
-      "- Layer normalization and residual connections between sub-layers\n",
-      "- No recurrent or convolutional elements, enabling parallel processing\n",
-      "\n",
-      "Self-Attention Mechanism:\n",
-      "- Processes relationships between all positions in a sequence simultaneously\n",
-      "- Computes attention weights using queries, keys, and values derived from input representations\n",
-      "- Implements scaled dot-product attention to prevent gradient issues with large input dimensions\n",
-      "- Allows direct modeling of dependencies regardless of positional distance\n",
-      "- Uses masking in decoder to prevent leftward information flow and maintain auto-regressive property\n",
-      "\n",
-      "Multi-Head Attention:\n",
-      "- Employs multiple attention heads operating in parallel\n",
-      "- Each head processes information in different representation subspaces\n",
-      "- Three types of attention applications:\n",
-      "  1. Encoder self-attention (all positions attend to each other)\n",
-      "  2. Decoder self-attention (each position attends to previous positions)\n",
-      "  3. Encoder-decoder attention (decoder queries attend to encoder outputs)\n",
-      "- Counteracts reduced resolution from attention averaging through parallel processing\n",
-      "\n",
-      "Position-wise Feed-Forward Network:\n",
-      "- Applied identically to each position separately\n",
-      "- Consists of two linear transformations with ReLU activation\n",
-      "- Structure: FFN(x) = max(0, xW1 + b1)W2 + b2\n",
-      "- Input and output dimensionality: dmodel = 512\n",
-      "- Inner-layer dimensionality: dff = 2048\n",
-      "- Parameters vary between layers but remain constant across positions\n",
-      "\n",
-      "Position Encoding:\n",
-      "- Adds positional information to input embeddings\n",
-      "- Enables the model to consider sequential order without recurrence\n",
-      "- Implements sinusoidal position encodings to allow model to attend to relative positions\n",
-      "- Maintains constant number of operations between any two positions, unlike convolutional approaches\n",
-      "- Allows effective modeling of both local and long-range dependencies\n",
-      "\n",
-      "\n",
-      "\n",
-      "## Performance and Applications\n",
-      "\n",
-      "The Transformer model demonstrates significant performance advantages and practical applications across multiple domains:\n",
-      "\n",
-      "Performance Advantages over RNN/CNN Models:\n",
-      "- Eliminates sequential computation constraints present in RNNs, enabling superior parallelization\n",
-      "- Reduces operations needed for relating distant positions to a constant number, compared to linear/logarithmic scaling in CNNs\n",
-      "- Processes all input and output positions simultaneously through self-attention mechanisms\n",
-      "- Achieves state-of-the-art results while requiring significantly less computational resources\n",
-      "\n",
-      "Machine Translation Benchmarks:\n",
-      "- WMT 2014 English-to-German: 28.4 BLEU score, exceeding previous best results by over 2 BLEU points\n",
-      "- WMT 2014 English-to-French: 41.8 BLEU score (single-model state-of-the-art)\n",
-      "- Surpasses performance of existing model ensembles in translation tasks\n",
-      "\n",
-      "Training Efficiency:\n",
-      "- Requires only 3.5 days of training on eight GPUs for state-of-the-art performance\n",
-      "- Achieves superior results at \"a small fraction of the training costs\" compared to previous models\n",
-      "- Enables significantly faster training through parallel processing of input/output sequences\n",
-      "- Can reach production-quality performance in as little as twelve hours on modern GPU hardware\n",
-      "\n",
-      "Real-world Applications:\n",
-      "- Machine translation systems\n",
-      "- Natural language understanding tasks\n",
-      "- Reading comprehension\n",
-      "- Abstractive summarization\n",
-      "- Text entailment analysis\n",
-      "- Constituency parsing (achieving 92.7 F1 score in semi-supervised settings)\n",
-      "- Adaptable to both large and limited training data scenarios\n",
-      "\n",
-      "Scalability Benefits:\n",
-      "- Highly parallelizable architecture enables efficient scaling across multiple GPUs\n",
-      "- Constant computational complexity for relating any input/output positions\n",
-      "- Effective handling of long-range dependencies in sequences\n",
-      "- Maintains performance quality while scaling to larger datasets and model sizes\n",
-      "- Generalizes well across different tasks and domains without architectural changes\n",
-      "- Supports efficient inference and deployment in production environments\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "report_response = await report_client.aget()\n",
-    "report_text = \"\\n\\n\".join([block.template for block in report_response.report.blocks])\n",
-    "print(report_text)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We can also see the sources for each block!"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "0.99687636\n",
-      "# Abstract\n",
-      "\n",
-      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
-      "==================\n",
-      "0.99591404\n",
-      "# 2 Background\n",
-      "\n",
-      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
-      "==================\n",
-      "0.9951325\n",
-      "# 1 Introduction\n",
-      "\n",
-      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
-      "==================\n",
-      "0.99442345\n",
-      "# 7 Conclusion\n",
-      "\n",
-      "In this work, we presented the Transformer, the first sequence transduction model ba\n",
-      "==================\n",
-      "0.9967649\n",
-      "# 3.2.3 Applications of Attention in our Model\n",
-      "\n",
-      "The Transformer uses multi-head attention in three d\n",
-      "==================\n",
-      "0.99533635\n",
-      "# 2 Background\n",
-      "\n",
-      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
-      "==================\n",
-      "0.9935868\n",
-      "# Abstract\n",
-      "\n",
-      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
-      "==================\n",
-      "0.98780584\n",
-      "# Outputs\n",
-      "\n",
-      "(shifted right)\n",
-      "\n",
-      "Figure 1: The Transformer - model architecture.\n",
-      "\n",
-      "The Transformer follows\n",
-      "==================\n",
-      "0.9205043\n",
-      "# 3.3 Position-wise Feed-Forward Networks\n",
-      "\n",
-      "In addition to attention sub-layers, each of the layers i\n",
-      "==================\n",
-      "0.79581684\n",
-      "# 1 Introduction\n",
-      "\n",
-      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
-      "==================\n",
-      "0.9946774\n",
-      "# Abstract\n",
-      "\n",
-      "The dominant sequence transduction models are based on complex recurrent or convolutiona\n",
-      "==================\n",
-      "0.97079873\n",
-      "# 7 Conclusion\n",
-      "\n",
-      "In this work, we presented the Transformer, the first sequence transduction model ba\n",
-      "==================\n",
-      "0.9535353\n",
-      "# 6.3 English Constituency Parsing\n",
-      "\n",
-      "To evaluate if the Transformer can generalize to other tasks we \n",
-      "==================\n",
-      "0.9514138\n",
-      "# 2 Background\n",
-      "\n",
-      "The goal of reducing sequential computation also forms the foundation of the Extende\n",
-      "==================\n",
-      "0.9790758\n",
-      "# 1 Introduction\n",
-      "\n",
-      "Recurrent neural networks, long short-term memory [13] and gated recurrent [7] neu\n",
-      "==================\n",
-      "0.92262185\n",
-      "# Outputs\n",
-      "\n",
-      "(shifted right)\n",
-      "\n",
-      "Figure 1: The Transformer - model architecture.\n",
-      "\n",
-      "The Transformer follows\n",
-      "==================\n"
-     ]
-    }
-   ],
-   "source": [
-    "for block in report_response.report.blocks:\n",
-    "    # Each block has a list of sources, which are the nodes that were used to generate the block\n",
-    "    for source in block.sources:\n",
-    "        print(source.score)\n",
-    "        print(source.node.text[:100])\n",
-    "        print(\"==================\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "llama-parse-aNC435Vv-py3.10",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
@@ -0,0 +1,19 @@
+{
+  "name": "llama-cloud-services-workspace",
+  "version": "0.0.1",
+  "description": "",
+  "private": true,
+  "keywords": [],
+  "author": "",
+  "devDependencies": {
+    "prettier": "^3.6.2",
+    "lint-staged": "^15.4.2"
+  },
+  "lint-staged": {
+    "ts/llama_cloud_services/src/**/*.{ts,tsx,js,jsx}": [
+      "pnpm --filter llama-cloud-services exec eslint --fix",
+      "pnpm --filter llama-cloud-services exec prettier --write"
+    ]
+  },
+  "packageManager": "pnpm@10.11.1+sha512.e519b9f7639869dc8d5c3c5dfef73b3f091094b0a006d7317353c72b124e80e1afd429732e28705ad6bfa1ee879c1fce46c128ccebd3192101f43dd67c667912"
+}
@@ -6,6 +6,15 @@ settings:

 importers:

+  .:
+    devDependencies:
+      lint-staged:
+        specifier: ^15.4.2
+        version: 15.5.2
+      prettier:
+        specifier: ^3.6.2
+        version: 3.6.2
+
  ts/e2e-tests:
    devDependencies:
      '@types/node':
@@ -829,6 +838,10 @@ packages:
  ajv@8.17.1:
    resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==}

+  ansi-escapes@7.0.0:
+    resolution: {integrity: sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==}
+    engines: {node: '>=18'}
+
  ansi-regex@5.0.1:
    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
    engines: {node: '>=8'}
@@ -933,6 +946,10 @@ packages:
    resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==}
    engines: {node: '>=6'}

+  cli-truncate@4.0.0:
+    resolution: {integrity: sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==}
+    engines: {node: '>=18'}
+
  cliui@8.0.1:
    resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==}
    engines: {node: '>=12'}
@@ -944,10 +961,17 @@ packages:
  color-name@1.1.4:
    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}

+  colorette@2.0.20:
+    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
+
  commander@13.0.0:
    resolution: {integrity: sha512-oPYleIY8wmTVzkvQq10AEok6YcTC4sRUBl8F9gVuwchGVUCTbl/vhLTaQqutuuySYOsu8YTgV+OxKc/8Yvx+mQ==}
    engines: {node: '>=18'}

+  commander@13.1.0:
+    resolution: {integrity: sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==}
+    engines: {node: '>=18'}
+
  commondir@1.0.1:
    resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}

@@ -1007,6 +1031,10 @@ packages:
  emoji-regex@9.2.2:
    resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==}

+  environment@1.1.0:
+    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
+    engines: {node: '>=18'}
+
  es-module-lexer@1.7.0:
    resolution: {integrity: sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==}

@@ -1071,6 +1099,13 @@ packages:
    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
    engines: {node: '>=0.10.0'}

+  eventemitter3@5.0.1:
+    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
+
+  execa@8.0.1:
+    resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
+    engines: {node: '>=16.17'}
+
  expect-type@1.2.2:
    resolution: {integrity: sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==}
    engines: {node: '>=12.0.0'}
@@ -1152,6 +1187,14 @@ packages:
    resolution: {integrity: sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==}
    engines: {node: '>=18'}

+  get-east-asian-width@1.3.1:
+    resolution: {integrity: sha512-R1QfovbPsKmosqTnPoRFiJ7CF9MLRgb53ChvMZm+r4p76/+8yKDy17qLL2PKInORy2RkZZekuK0efYgmzTkXyQ==}
+    engines: {node: '>=18'}
+
+  get-stream@8.0.1:
+    resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==}
+    engines: {node: '>=16'}
+
  get-tsconfig@4.10.1:
    resolution: {integrity: sha512-auHyJ4AgMz7vgS8Hp3N6HXSmlMdUyhSUrfBF16w153rxtLIEOE+HGqaBppczZvnHLqQJfiHotCYpNhl0lUROFQ==}

@@ -1198,6 +1241,10 @@ packages:
  html-escaper@2.0.2:
    resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==}

+  human-signals@5.0.0:
+    resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}
+    engines: {node: '>=16.17.0'}
+
  ieee754@1.2.1:
    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}

@@ -1229,6 +1276,14 @@ packages:
    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
    engines: {node: '>=8'}

+  is-fullwidth-code-point@4.0.0:
+    resolution: {integrity: sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==}
+    engines: {node: '>=12'}
+
+  is-fullwidth-code-point@5.1.0:
+    resolution: {integrity: sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==}
+    engines: {node: '>=18'}
+
  is-glob@4.0.3:
    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
    engines: {node: '>=0.10.0'}
@@ -1251,6 +1306,10 @@ packages:
  is-reference@1.2.1:
    resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}

+  is-stream@3.0.0:
+    resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
  is-unicode-supported@1.3.0:
    resolution: {integrity: sha512-43r2mRvz+8JRIKnWJ+3j8JtjRKZ6GmjzfaE/qiBJnikNnYv/6bagRJ1kUhNk8R5EX/GkobD+r+sfxCPJsiKBLQ==}
    engines: {node: '>=12'}
@@ -1314,6 +1373,19 @@ packages:
    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
    engines: {node: '>= 0.8.0'}

+  lilconfig@3.1.3:
+    resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==}
+    engines: {node: '>=14'}
+
+  lint-staged@15.5.2:
+    resolution: {integrity: sha512-YUSOLq9VeRNAo/CTaVmhGDKG+LBtA8KF1X4K5+ykMSwWST1vDxJRB2kv2COgLb1fvpCo+A/y9A0G0znNVmdx4w==}
+    engines: {node: '>=18.12.0'}
+    hasBin: true
+
+  listr2@8.3.3:
+    resolution: {integrity: sha512-LWzX2KsqcB1wqQ4AHgYb4RsDXauQiqhjLk+6hjbaeHG4zpjjVAB6wC/gz6X0l+Du1cN3pUB5ZlrvTbhGSNnUQQ==}
+    engines: {node: '>=18.0.0'}
+
  locate-path@6.0.0:
    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
    engines: {node: '>=10'}
@@ -1328,6 +1400,10 @@ packages:
    resolution: {integrity: sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==}
    engines: {node: '>=18'}

+  log-update@6.1.0:
+    resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
+    engines: {node: '>=18'}
+
  loupe@3.2.0:
    resolution: {integrity: sha512-2NCfZcT5VGVNX9mSZIxLRkEAegDGBpuQZBy13desuHeVORmBDyAET4TkJr4SjqQy3A8JDofMN6LpkK8Xcm/dlw==}

@@ -1347,6 +1423,9 @@ packages:
    resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==}
    engines: {node: '>=10'}

+  merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+
  merge2@1.4.1:
    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
    engines: {node: '>= 8'}
@@ -1355,6 +1434,10 @@ packages:
    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
    engines: {node: '>=8.6'}

+  mimic-fn@4.0.0:
+    resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
+    engines: {node: '>=12'}
+
  mimic-function@5.0.1:
    resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
    engines: {node: '>=18'}
@@ -1414,6 +1497,10 @@ packages:
  node-fetch-native@1.6.7:
    resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==}

+  npm-run-path@5.3.0:
+    resolution: {integrity: sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+
  nypm@0.5.4:
    resolution: {integrity: sha512-X0SNNrZiGU8/e/zAB7sCTtdxWTMSIO73q+xuKgglm2Yvzwlo8UoC5FNySQFCvl84uPaeADkqHUZUkWy4aH4xOA==}
    engines: {node: ^14.16.0 || >=16.10.0}
@@ -1422,6 +1509,10 @@ packages:
  ohash@1.1.6:
    resolution: {integrity: sha512-TBu7PtV8YkAZn0tSxobKY2n2aAQva936lhRrj6957aDaCf9IEtqsKbgMzXE/F/sjqYOwmrukeORHNLe5glk7Cg==}

+  onetime@6.0.0:
+    resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
+    engines: {node: '>=12'}
+
  onetime@7.0.0:
    resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
    engines: {node: '>=18'}
@@ -1461,6 +1552,10 @@ packages:
    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
    engines: {node: '>=8'}

+  path-key@4.0.0:
+    resolution: {integrity: sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==}
+    engines: {node: '>=12'}
+
  path-parse@1.0.7:
    resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}

@@ -1492,6 +1587,11 @@ packages:
    resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==}
    engines: {node: '>=12'}

+  pidtree@0.6.0:
+    resolution: {integrity: sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==}
+    engines: {node: '>=0.10'}
+    hasBin: true
+
  pkg-types@1.3.1:
    resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==}

@@ -1558,6 +1658,9 @@ packages:
    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}

+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
  rollup-plugin-dts@6.2.1:
    resolution: {integrity: sha512-sR3CxYUl7i2CHa0O7bA45mCrgADyAQ0tVtGSqi3yvH28M+eg1+g5d7kQ9hLvEz5dorK3XVsH5L2jwHLQf72DzA==}
    engines: {node: '>=16'}
@@ -1609,6 +1712,14 @@ packages:
    resolution: {integrity: sha512-FoqMu0NCGBLCcAkS1qA+XJIQTR6/JHfQXl+uGteNCQ76T91DMUjPa9xfmeqMY3z80nLSg9yQmNjK0Px6RWsH/A==}
    engines: {node: '>=18'}

+  slice-ansi@5.0.0:
+    resolution: {integrity: sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==}
+    engines: {node: '>=12'}
+
+  slice-ansi@7.1.0:
+    resolution: {integrity: sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==}
+    engines: {node: '>=18'}
+
  source-map-js@1.2.1:
    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
    engines: {node: '>=0.10.0'}
@@ -1627,6 +1738,10 @@ packages:
    resolution: {integrity: sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ==}
    engines: {node: '>=18'}

+  string-argv@0.3.2:
+    resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
+    engines: {node: '>=0.6.19'}
+
  string-width@4.2.3:
    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
    engines: {node: '>=8'}
@@ -1647,6 +1762,10 @@ packages:
    resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==}
    engines: {node: '>=12'}

+  strip-final-newline@3.0.0:
+    resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
+    engines: {node: '>=12'}
+
  strip-json-comments@3.1.1:
    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
    engines: {node: '>=8'}
@@ -1871,6 +1990,10 @@ packages:
    resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==}
    engines: {node: '>=12'}

+  wrap-ansi@9.0.0:
+    resolution: {integrity: sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==}
+    engines: {node: '>=18'}
+
  y18n@5.0.8:
    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
    engines: {node: '>=10'}
@@ -1878,6 +2001,11 @@ packages:
  yallist@4.0.0:
    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}

+  yaml@2.8.1:
+    resolution: {integrity: sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==}
+    engines: {node: '>= 14.6'}
+    hasBin: true
+
  yargs-parser@21.1.1:
    resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
    engines: {node: '>=12'}
@@ -2551,6 +2679,10 @@ snapshots:
      json-schema-traverse: 1.0.0
      require-from-string: 2.0.2

+  ansi-escapes@7.0.0:
+    dependencies:
+      environment: 1.1.0
+
  ansi-regex@5.0.1: {}

  ansi-regex@6.1.0: {}
@@ -2665,6 +2797,11 @@ snapshots:

  cli-spinners@2.9.2: {}

+  cli-truncate@4.0.0:
+    dependencies:
+      slice-ansi: 5.0.0
+      string-width: 7.2.0
+
  cliui@8.0.1:
    dependencies:
      string-width: 4.2.3
@@ -2677,8 +2814,12 @@ snapshots:

  color-name@1.1.4: {}

+  colorette@2.0.20: {}
+
  commander@13.0.0: {}

+  commander@13.1.0: {}
+
  commondir@1.0.1: {}

  concat-map@0.0.1: {}
@@ -2717,6 +2858,8 @@ snapshots:

  emoji-regex@9.2.2: {}

+  environment@1.1.0: {}
+
  es-module-lexer@1.7.0: {}

  esbuild@0.21.5:
@@ -2824,6 +2967,20 @@ snapshots:

  esutils@2.0.3: {}

+  eventemitter3@5.0.1: {}
+
+  execa@8.0.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 8.0.1
+      human-signals: 5.0.0
+      is-stream: 3.0.0
+      merge-stream: 2.0.0
+      npm-run-path: 5.3.0
+      onetime: 6.0.0
+      signal-exit: 4.1.0
+      strip-final-newline: 3.0.0
+
  expect-type@1.2.2: {}

  fast-deep-equal@3.1.3: {}
@@ -2899,6 +3056,10 @@ snapshots:

  get-east-asian-width@1.3.0: {}

+  get-east-asian-width@1.3.1: {}
+
+  get-stream@8.0.1: {}
+
  get-tsconfig@4.10.1:
    dependencies:
      resolve-pkg-maps: 1.0.0
@@ -2953,6 +3114,8 @@ snapshots:

  html-escaper@2.0.2: {}

+  human-signals@5.0.0: {}
+
  ieee754@1.2.1: {}

  ignore@5.3.2: {}
@@ -2974,6 +3137,12 @@ snapshots:

  is-fullwidth-code-point@3.0.0: {}

+  is-fullwidth-code-point@4.0.0: {}
+
+  is-fullwidth-code-point@5.1.0:
+    dependencies:
+      get-east-asian-width: 1.3.1
+
  is-glob@4.0.3:
    dependencies:
      is-extglob: 2.1.1
@@ -2990,6 +3159,8 @@ snapshots:
    dependencies:
      '@types/estree': 1.0.8

+  is-stream@3.0.0: {}
+
  is-unicode-supported@1.3.0: {}

  is-unicode-supported@2.1.0: {}
@@ -3053,6 +3224,32 @@ snapshots:
      prelude-ls: 1.2.1
      type-check: 0.4.0

+  lilconfig@3.1.3: {}
+
+  lint-staged@15.5.2:
+    dependencies:
+      chalk: 5.5.0
+      commander: 13.1.0
+      debug: 4.4.1
+      execa: 8.0.1
+      lilconfig: 3.1.3
+      listr2: 8.3.3
+      micromatch: 4.0.8
+      pidtree: 0.6.0
+      string-argv: 0.3.2
+      yaml: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  listr2@8.3.3:
+    dependencies:
+      cli-truncate: 4.0.0
+      colorette: 2.0.20
+      eventemitter3: 5.0.1
+      log-update: 6.1.0
+      rfdc: 1.4.1
+      wrap-ansi: 9.0.0
+
  locate-path@6.0.0:
    dependencies:
      p-locate: 5.0.0
@@ -3066,6 +3263,14 @@ snapshots:
      chalk: 5.5.0
      is-unicode-supported: 1.3.0

+  log-update@6.1.0:
+    dependencies:
+      ansi-escapes: 7.0.0
+      cli-cursor: 5.0.0
+      slice-ansi: 7.1.0
+      strip-ansi: 7.1.0
+      wrap-ansi: 9.0.0
+
  loupe@3.2.0: {}

  lru-cache@10.4.3: {}
@@ -3086,6 +3291,8 @@ snapshots:
    dependencies:
      semver: 7.7.2

+  merge-stream@2.0.0: {}
+
  merge2@1.4.1: {}

  micromatch@4.0.8:
@@ -3093,6 +3300,8 @@ snapshots:
      braces: 3.0.3
      picomatch: 2.3.1

+  mimic-fn@4.0.0: {}
+
  mimic-function@5.0.1: {}

  minimatch@3.1.2:
@@ -3139,6 +3348,10 @@ snapshots:

  node-fetch-native@1.6.7: {}

+  npm-run-path@5.3.0:
+    dependencies:
+      path-key: 4.0.0
+
  nypm@0.5.4:
    dependencies:
      citty: 0.1.6
@@ -3150,6 +3363,10 @@ snapshots:

  ohash@1.1.6: {}

+  onetime@6.0.0:
+    dependencies:
+      mimic-fn: 4.0.0
+
  onetime@7.0.0:
    dependencies:
      mimic-function: 5.0.1
@@ -3199,6 +3416,8 @@ snapshots:

  path-key@3.1.1: {}

+  path-key@4.0.0: {}
+
  path-parse@1.0.7: {}

  path-scurry@1.11.1:
@@ -3220,6 +3439,8 @@ snapshots:

  picomatch@4.0.3: {}

+  pidtree@0.6.0: {}
+
  pkg-types@1.3.1:
    dependencies:
      confbox: 0.1.8
@@ -3272,6 +3493,8 @@ snapshots:

  reusify@1.1.0: {}

+  rfdc@1.4.1: {}
+
  rollup-plugin-dts@6.2.1(rollup@4.46.2)(typescript@5.9.2):
    dependencies:
      magic-string: 0.30.17
@@ -3342,6 +3565,16 @@ snapshots:
      mrmime: 2.0.1
      totalist: 3.0.1

+  slice-ansi@5.0.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      is-fullwidth-code-point: 4.0.0
+
+  slice-ansi@7.1.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      is-fullwidth-code-point: 5.1.0
+
  source-map-js@1.2.1: {}

  source-map@0.6.1: {}
@@ -3352,6 +3585,8 @@ snapshots:

  stdin-discarder@0.2.2: {}

+  string-argv@0.3.2: {}
+
  string-width@4.2.3:
    dependencies:
      emoji-regex: 8.0.0
@@ -3378,6 +3613,8 @@ snapshots:
    dependencies:
      ansi-regex: 6.1.0

+  strip-final-newline@3.0.0: {}
+
  strip-json-comments@3.1.1: {}

  strtok3@10.3.4:
@@ -3584,10 +3821,18 @@ snapshots:
      string-width: 5.1.2
      strip-ansi: 7.1.0

+  wrap-ansi@9.0.0:
+    dependencies:
+      ansi-styles: 6.2.1
+      string-width: 7.2.0
+      strip-ansi: 7.1.0
+
  y18n@5.0.8: {}

  yallist@4.0.0: {}

+  yaml@2.8.1: {}
+
  yargs-parser@21.1.1: {}

  yargs@17.7.2:
@@ -9,7 +9,6 @@ This repository contains the code for hand-written SDKs and clients for interact
 This includes:

 - [LlamaParse](../parse.md) - A GenAI-native document parser that can parse complex document data for any downstream LLM use case (Agents, RAG, data processing, etc.).
- [LlamaReport (beta/invite-only)](../report.md) - A prebuilt agentic report builder that can be used to build reports from a variety of data sources.
 - [LlamaExtract](../extract.md) - A prebuilt agentic data extractor that can be used to transform data into a structured JSON representation.
 - [LlamaCloud Index](../index.md) - A widely customizable and fully automated document ingestion pipeline that also serves retrieval purposes.

@@ -28,14 +27,12 @@ Then, you can use the services in your code:
 ```python
 from llama_cloud_services import (
    LlamaParse,
-    LlamaReport,
    LlamaExtract,
    LlamaCloudIndex,
 )
-from llama_cloud_services import LlamaParse, LlamaReport, LlamaExtract
+from llama_cloud_services import LlamaParse, LlamaExtract

 parser = LlamaParse(api_key="YOUR_API_KEY")
-report = LlamaReport(api_key="YOUR_API_KEY")
 extract = LlamaExtract(api_key="YOUR_API_KEY")
 index = LlamaCloudIndex(
    "my_first_index", project_name="default", api_key="YOUR_API_KEY"
@@ -45,7 +42,6 @@ index = LlamaCloudIndex(
 See the quickstart guides for each service for more information:

 - [LlamaParse](../parse.md)
- [LlamaReport (beta/invite-only)](../report.md)
 - [LlamaExtract](../extract.md)
 - [LlamaCloud Index](../index.md)

@@ -58,13 +54,11 @@ You can also create your API key in the EU region [here](https://cloud.eu.llamai
 ```python
 from llama_cloud_services import (
    LlamaParse,
-    LlamaReport,
    LlamaExtract,
    EU_BASE_URL,
 )

 parser = LlamaParse(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
-report = LlamaReport(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
 extract = LlamaExtract(api_key="YOUR_API_KEY", base_url=EU_BASE_URL)
 index = LlamaCloudIndex(
    "my_first_index",
@@ -1,5 +1,4 @@
 from llama_cloud_services.parse import LlamaParse
-from llama_cloud_services.report import ReportClient, LlamaReport
 from llama_cloud_services.extract import LlamaExtract, ExtractionAgent, SourceText
 from llama_cloud_services.constants import EU_BASE_URL
 from llama_cloud_services.index import (
@@ -10,8 +9,6 @@ from llama_cloud_services.index import (

 __all__ = [
    "LlamaParse",
-    "ReportClient",
-    "LlamaReport",
    "LlamaExtract",
    "ExtractionAgent",
    "SourceText",
@@ -9,7 +9,6 @@ from llama_cloud.types import (
    ClassifyJobResults,
    ClassifyParsingConfiguration,
    StatusEnum,
-    ClassifyJobWithStatus,
    File,
 )
 from llama_cloud.resources.classifier.client import OMIT
@@ -229,7 +228,7 @@ class ClassifyClient:
                )
            )

-    async def wait_for_job_completion(self, job_id: str) -> ClassifyJobWithStatus:
+    async def wait_for_job_completion(self, job_id: str) -> ClassifyJob:
        """
        Wait for a classify job to complete.
        Meant to expose lower level access to classifier jobs for advanced use cases.
@@ -396,6 +396,10 @@ class LlamaParse(BasePydanticReader):
        default=False,
        description="If set, the parser will try to preserve very small text lines. This can be useful for documents containing vector graphics with very small text lines that may not be recognized by OCR or a vision model (such as in CAD drawings).",
    )
+    precise_bounding_box: Optional[bool] = Field(
+        default=False,
+        description="If set to true, the parser will use a more precise bounding box to extract text from documents. This will increase the accuracy of the parsing job, but reduce the speed.",
+    )
    replace_failed_page_mode: Optional[FailedPageMode] = Field(
        default=None,
        description="The mode to use to replace the failed page, see FailedPageMode enum for possible value. If set, the parser will replace the failed page with the specified mode. If not set, the default mode (raw_text) will be used.",
@@ -416,7 +420,18 @@ class LlamaParse(BasePydanticReader):
        default=False,
        description="If set to true, the parser will extract sub-tables from the spreadsheet when possible (more than one table per sheet).",
    )
-
+    specialized_chart_parsing_agentic: Optional[bool] = Field(
+        default=False,
+        description="If set to true, the parser will use a specialized agentic chart parsing model to extract data from charts. This model is able to understand the chart type and extract the data accordingly.",
+    )
+    specialized_chart_parsing_efficient: Optional[bool] = Field(
+        default=False,
+        description="If set to true, the parser will use a specialized efficient chart parsing model to extract data from charts. This model is faster and cheaper than the agentic model, but may be less accurate.",
+    )
+    specialized_chart_parsing_plus: Optional[bool] = Field(
+        default=False,
+        description="If set to true, the parser will use a specialized one-shot chart parsing model to extract data from charts. This model is able to understand the chart type and extract the data accordingly. It is more accurate than the efficient model, but also more expensive.",
+    )
    strict_mode_buggy_font: Optional[bool] = Field(
        default=False,
        description="If set to true, the parser will fail if it can't extract text from a document because of a buggy font.",
@@ -928,6 +943,9 @@ class LlamaParse(BasePydanticReader):
        if self.preset is not None:
            data["preset"] = self.preset

+        if self.precise_bounding_box:
+            data["precise_bounding_box"] = self.precise_bounding_box
+
        if self.replace_failed_page_mode is not None:
            data["replace_failed_page_mode"] = self.replace_failed_page_mode.value

@@ -947,6 +965,19 @@ class LlamaParse(BasePydanticReader):
        if self.spreadsheet_extract_sub_tables:
            data["spreadsheet_extract_sub_tables"] = self.spreadsheet_extract_sub_tables

+        if self.specialized_chart_parsing_agentic:
+            data[
+                "specialized_chart_parsing_agentic"
+            ] = self.specialized_chart_parsing_agentic
+
+        if self.specialized_chart_parsing_efficient:
+            data[
+                "specialized_chart_parsing_efficient"
+            ] = self.specialized_chart_parsing_efficient
+
+        if self.specialized_chart_parsing_plus:
+            data["specialized_chart_parsing_plus"] = self.specialized_chart_parsing_plus
+
        if self.strict_mode_buggy_font:
            data["strict_mode_buggy_font"] = self.strict_mode_buggy_font

@@ -1042,7 +1073,11 @@ class LlamaParse(BasePydanticReader):
        return current_interval  # Default fallback

    async def _get_job_result(
-        self, job_id: str, result_type: str, verbose: bool = False
+        self,
+        job_id: str,
+        result_type: str,
+        verbose: bool = False,
+        raise_job_error: bool = True,
    ) -> Dict[str, Any]:
        start = time.time()
        tries = 0
@@ -1075,7 +1110,25 @@ class LlamaParse(BasePydanticReader):
                        print(".", end="", flush=True)
                    current_interval = self._calculate_backoff(current_interval)
                else:
-                    raise JobFailedException.from_result(result_json)
+                    if raise_job_error:
+                        raise JobFailedException.from_result(result_json)
+                    else:
+                        error_code = result_json.get("error_code")
+                        error_message = result_json.get("error_message")
+
+                        error_parts = [f"Job ID: {job_id} failed with status: {status}"]
+                        if error_code:
+                            error_parts.append(f"Error code: {error_code}")
+                        if error_message:
+                            error_parts.append(f"Error message: {error_message}")
+                        error_str = ", ".join(error_parts)
+
+                        return {
+                            "pages": [],
+                            "job_metadata": {"job_pages": 0},
+                            "error": error_str,
+                            "status": status,
+                        }
            except (
                httpx.ConnectError,
                httpx.ReadError,
@@ -1106,6 +1159,7 @@ class LlamaParse(BasePydanticReader):
        fs: Optional[AbstractFileSystem] = None,
        result_type: Optional[str] = None,
        num_workers: Optional[int] = None,
+        raise_job_error: bool = True,
    ) -> List[Tuple[str, Dict[str, Any]]]:
        if self.partition_pages is None:
            job_results = [
@@ -1114,6 +1168,7 @@ class LlamaParse(BasePydanticReader):
                    extra_info=extra_info,
                    fs=fs,
                    result_type=result_type,
+                    raise_job_error=raise_job_error,
                )
            ]
        else:
@@ -1123,6 +1178,7 @@ class LlamaParse(BasePydanticReader):
                fs=fs,
                result_type=result_type,
                num_workers=num_workers,
+                raise_job_error=raise_job_error,
            )
        return job_results

@@ -1132,6 +1188,7 @@ class LlamaParse(BasePydanticReader):
        extra_info: Optional[dict] = None,
        fs: Optional[AbstractFileSystem] = None,
        result_type: Optional[str] = None,
+        raise_job_error: bool = True,
        **create_kwargs: Any,
    ) -> Tuple[str, Dict[str, Any]]:
        """Create one parse job and wait for the result."""
@@ -1141,7 +1198,10 @@ class LlamaParse(BasePydanticReader):
        if self.verbose:
            print("Started parsing the file under job_id %s" % job_id)
        result = await self._get_job_result(
-            job_id, result_type or self.result_type.value, verbose=self.verbose
+            job_id,
+            result_type or self.result_type.value,
+            verbose=self.verbose,
+            raise_job_error=raise_job_error,
        )
        return job_id, result

@@ -1152,6 +1212,7 @@ class LlamaParse(BasePydanticReader):
        fs: Optional[AbstractFileSystem] = None,
        result_type: Optional[str] = None,
        num_workers: Optional[int] = None,
+        raise_job_error: bool = True,
    ) -> List[Tuple[str, Dict[str, Any]]]:
        """Partition a file and run separate parse jobs per partition segment."""
        assert self.partition_pages is not None
@@ -1166,6 +1227,7 @@ class LlamaParse(BasePydanticReader):
                    extra_info=extra_info,
                    fs=fs,
                    result_type=result_type,
+                    raise_job_error=raise_job_error,
                    partition_target_pages=target_pages,
                )
                for target_pages in partition_pages(
@@ -1193,28 +1255,33 @@ class LlamaParse(BasePydanticReader):
                size = self.partition_pages
            if not size:
                break
-            try:
-                # Fetch JSON result type first to get accurate pagination data
-                # and then fetch the user's desired result type if needed
-                job_id, json_result = await self._parse_one_unpartitioned(
-                    file_path,
-                    extra_info=extra_info,
-                    fs=fs,
-                    result_type=ResultType.JSON.value,
-                    partition_target_pages=f"{total}-{total + size - 1}",
-                )
-                result_type = result_type or self.result_type.value
-                if result_type == ResultType.JSON.value:
-                    job_result = json_result
-                else:
-                    job_result = await self._get_job_result(
-                        job_id, result_type, verbose=self.verbose
-                    )
-            except JobFailedException as e:
-                if results and e.error_code == "NO_DATA_FOUND_IN_FILE":
-                    # Expected when we try to read past the end of the file
+            # Fetch JSON result type first to get accurate pagination data
+            # and then fetch the user's desired result type if needed
+            job_id, json_result = await self._parse_one_unpartitioned(
+                file_path,
+                extra_info=extra_info,
+                fs=fs,
+                result_type=ResultType.JSON.value,
+                raise_job_error=raise_job_error,
+                partition_target_pages=f"{total}-{total + size - 1}",
+            )
+
+            if json_result.get("error"):
+                if results and "NO_DATA_FOUND_IN_FILE" in json_result.get("error", ""):
                    return results
-                raise
+                results.append((job_id, json_result))
+                return results
+
+            result_type = result_type or self.result_type.value
+            if result_type == ResultType.JSON.value:
+                job_result = json_result
+            else:
+                job_result = await self._get_job_result(
+                    job_id,
+                    result_type,
+                    verbose=self.verbose,
+                    raise_job_error=raise_job_error,
+                )
            results.append((job_id, job_result))
            if len(json_result["pages"]) < size:
                break
@@ -1328,6 +1395,7 @@ class LlamaParse(BasePydanticReader):
        extra_info: Optional[dict] = None,
        fs: Optional[AbstractFileSystem] = None,
        num_workers: Optional[int] = None,
+        raise_job_error: bool = True,
    ) -> List[JobResult]:
        job_results = await self._parse_one(
            file_path,
@@ -1335,6 +1403,7 @@ class LlamaParse(BasePydanticReader):
            fs=fs,
            result_type=ResultType.JSON.value,
            num_workers=num_workers,
+            raise_job_error=raise_job_error,
        )
        return [
            JobResult(
@@ -1354,6 +1423,7 @@ class LlamaParse(BasePydanticReader):
        file_path: Union[List[FileInput], FileInput],
        extra_info: Optional[dict] = None,
        fs: Optional[AbstractFileSystem] = None,
+        raise_job_error: bool = True,
    ) -> Union[List["JobResult"], "JobResult"]:
        """
        Parse the file and return a JobResult object instead of Document objects.
@@ -1365,6 +1435,7 @@ class LlamaParse(BasePydanticReader):
            file_path: Path to the file to parse. Can be a string, path, bytes, file-like object, or a list of these.
            extra_info: Additional metadata to include in the result.
            fs: Optional filesystem to use for reading files.
+            raise_job_error: If True (default), raises JobFailedException when jobs fail. If False, returns JobResult objects with error information.

        Returns:
            JobResult object or list of JobResult objects if either multiple files were provided or file(s) were partitioned before parsing.
@@ -1380,7 +1451,11 @@ class LlamaParse(BasePydanticReader):
            else:
                file_name = str(file_path)
            result = await self._aparse_one(
-                file_path, file_name, extra_info=extra_info, fs=fs
+                file_path,
+                file_name,
+                extra_info=extra_info,
+                fs=fs,
+                raise_job_error=raise_job_error,
            )
            return result[0] if len(result) == 1 else result

@@ -1406,6 +1481,7 @@ class LlamaParse(BasePydanticReader):
                            extra_info=extra_info,
                            fs=fs,
                            num_workers=1,
+                            raise_job_error=raise_job_error,
                        )
                        for i, f in enumerate(file_path)
                    ],
@@ -1431,6 +1507,7 @@ class LlamaParse(BasePydanticReader):
        file_path: Union[List[FileInput], FileInput],
        extra_info: Optional[dict] = None,
        fs: Optional[AbstractFileSystem] = None,
+        raise_job_error: bool = True,
    ) -> Union[List["JobResult"], "JobResult"]:
        """
        Parse the file and return a JobResult object instead of Document objects.
@@ -1442,12 +1519,17 @@ class LlamaParse(BasePydanticReader):
            file_path: Path to the file to parse. Can be a string, path, bytes, file-like object, or a list of these.
            extra_info: Additional metadata to include in the result.
            fs: Optional filesystem to use for reading files.
+            raise_job_error: If True (default), raises JobFailedException when jobs fail. If False, returns JobResult objects with error information.

        Returns:
            JobResult object or list of JobResult objects if multiple files were provided
        """
        try:
-            return asyncio_run(self.aparse(file_path, extra_info, fs=fs))
+            return asyncio_run(
+                self.aparse(
+                    file_path, extra_info, fs=fs, raise_job_error=raise_job_error
+                )
+            )
        except RuntimeError as e:
            if nest_asyncio_err in str(e):
                raise RuntimeError(nest_asyncio_msg)
@@ -1714,7 +1796,7 @@ class LlamaParse(BasePydanticReader):
        return sub_docs

    async def aget_result(
-        self, job_id: Union[str, List[str]]
+        self, job_id: Union[str, List[str]], raise_job_error: bool = True
    ) -> Union[JobResult, List[JobResult]]:
        """
        Return JobResult object for previously parsed job(s).
@@ -1723,13 +1805,17 @@ class LlamaParse(BasePydanticReader):

        Args:
            job_id: Job ID or list of multiple Job IDs to be retrieved.
+            raise_job_error: If True (default), raises JobFailedException when jobs fail. If False, returns JobResult objects with error information.

        Returns:
            JobResult object or list of JobResult objects if multiple job IDs were provided.
        """
        if isinstance(job_id, str):
            result = await self._get_job_result(
-                job_id, ResultType.JSON.value, verbose=self.verbose
+                job_id,
+                ResultType.JSON.value,
+                verbose=self.verbose,
+                raise_job_error=raise_job_error,
            )
            return JobResult(
                job_id=job_id,
@@ -1743,7 +1829,12 @@ class LlamaParse(BasePydanticReader):
        elif isinstance(job_id, list):
            results = []
            jobs = [
-                self._get_job_result(id_, ResultType.JSON.value, verbose=self.verbose)
+                self._get_job_result(
+                    id_,
+                    ResultType.JSON.value,
+                    verbose=self.verbose,
+                    raise_job_error=raise_job_error,
+                )
                for id_ in job_id
            ]
            results = await run_jobs(
@@ -1768,7 +1859,7 @@ class LlamaParse(BasePydanticReader):
            raise ValueError("The input job_id must be a string or a list of strings.")

    def get_result(
-        self, job_id: Union[str, List[str]]
+        self, job_id: Union[str, List[str]], raise_job_error: bool = True
    ) -> Union[JobResult, List[JobResult]]:
        """
        Return JobResult object for previously parsed job(s).
@@ -1777,12 +1868,15 @@ class LlamaParse(BasePydanticReader):

        Args:
            job_id: Job ID or list of multiple Job IDs to be retrieved.
+            raise_job_error: If True (default), raises JobFailedException when jobs fail. If False, returns JobResult objects with error information.

        Returns:
            JobResult object or list of JobResult objects if multiple job IDs were provided.
        """
        try:
-            return asyncio_run(self.aget_result(job_id))
+            return asyncio_run(
+                self.aget_result(job_id, raise_job_error=raise_job_error)
+            )
        except RuntimeError as e:
            if nest_asyncio_err in str(e):
                raise RuntimeError(nest_asyncio_msg)
@@ -159,6 +159,9 @@ class Page(BaseModel):
    durationInSeconds: Optional[float] = Field(
        default=None, description="The duration of the audio transcript in seconds."
    )
+    slideSpeakerNotes: Optional[str] = Field(
+        default=None, description="The speaker notes for the slide."
+    )


 class JobResult(BaseModel):
@@ -1,4 +0,0 @@
-from llama_cloud_services.report.report import ReportClient
-from llama_cloud_services.report.base import LlamaReport
-
-__all__ = ["ReportClient", "LlamaReport"]
@@ -1,269 +0,0 @@
-import asyncio
-import httpx
-import os
-import io
-from concurrent.futures import ThreadPoolExecutor
-from typing import Optional, List, Union, Any, Coroutine, TypeVar
-from urllib.parse import urljoin
-
-from llama_cloud.types import ReportMetadata
-from llama_cloud_services.report.report import ReportClient
-
-T = TypeVar("T")
-
-
-class LlamaReport:
-    """Client for managing reports and general report operations."""
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        project_id: Optional[str] = None,
-        organization_id: Optional[str] = None,
-        base_url: Optional[str] = None,
-        timeout: Optional[int] = None,
-        async_httpx_client: Optional[httpx.AsyncClient] = None,
-    ):
-        self.api_key = api_key or os.getenv("LLAMA_CLOUD_API_KEY", None)
-        if not self.api_key:
-            raise ValueError("No API key provided.")
-
-        self.base_url = base_url or os.getenv(
-            "LLAMA_CLOUD_BASE_URL", "https://api.cloud.llamaindex.ai"
-        )
-        self.timeout = timeout or 60
-
-        # Initialize HTTP clients
-        self._aclient = async_httpx_client or httpx.AsyncClient(timeout=self.timeout)
-
-        # Set auth headers
-        self.headers = {
-            "Authorization": f"Bearer {self.api_key}",
-        }
-
-        self.organization_id = organization_id
-        self.project_id = project_id
-        self._client_params = {
-            "timeout": self._aclient.timeout,
-            "headers": self._aclient.headers,
-            "base_url": self._aclient.base_url,
-            "auth": self._aclient.auth,
-            "event_hooks": self._aclient.event_hooks,
-            "cookies": self._aclient.cookies,
-            "max_redirects": self._aclient.max_redirects,
-            "params": self._aclient.params,
-            "trust_env": self._aclient.trust_env,
-        }
-        self._thread_pool = ThreadPoolExecutor(
-            max_workers=min(10, (os.cpu_count() or 1) + 4)
-        )
-
-    @property
-    def aclient(self) -> httpx.AsyncClient:
-        if self._aclient is None:
-            self._aclient = httpx.AsyncClient(**self._client_params)
-        return self._aclient
-
-    def _run_sync(self, coro: Coroutine[Any, Any, T]) -> T:
-        """Run coroutine in a separate thread to avoid event loop issues"""
-
-        # force a new client for this thread/event loop
-        original_client = self._aclient
-        self._aclient = None
-
-        def run_coro() -> T:
-            async def wrapped_coro() -> T:
-                return await coro
-
-            return asyncio.run(wrapped_coro())
-
-        result = self._thread_pool.submit(run_coro).result()
-
-        # restore the original client
-        self._aclient = original_client
-
-        return result
-
-    async def _get_default_project(self) -> str:
-        response = await self.aclient.get(
-            urljoin(str(self.base_url), "/api/v1/projects"), headers=self.headers
-        )
-        response.raise_for_status()
-        projects = response.json()
-        default_project = [p for p in projects if p.get("is_default")]
-        return default_project[0]["id"]
-
-    async def _build_url(
-        self, endpoint: str, extra_params: Optional[List[str]] = None
-    ) -> str:
-        """Helper method to build URLs with common query parameters."""
-        url = urljoin(str(self.base_url), endpoint)
-
-        if not self.project_id:
-            self.project_id = await self._get_default_project()
-
-        query_params = []
-        if self.organization_id:
-            query_params.append(f"organization_id={self.organization_id}")
-        if self.project_id:
-            query_params.append(f"project_id={self.project_id}")
-        if extra_params:
-            query_params.extend([p for p in extra_params if p is not None])
-
-        if query_params:
-            url += "?" + "&".join(query_params)
-
-        return url
-
-    async def acreate_report(
-        self,
-        name: str,
-        template_instructions: Optional[str] = None,
-        template_text: Optional[str] = None,
-        template_file: Optional[Union[str, tuple[str, bytes]]] = None,
-        input_files: Optional[List[Union[str, tuple[str, bytes]]]] = None,
-        existing_retriever_id: Optional[str] = None,
-    ) -> ReportClient:
-        """Create a new report asynchronously."""
-        url = await self._build_url("/api/v1/reports/")
-        open_files: List[io.BufferedReader] = []
-
-        data = {"name": name}
-        if template_instructions:
-            data["template_instructions"] = template_instructions
-        if template_text:
-            data["template_text"] = template_text
-        if existing_retriever_id:
-            data["existing_retriever_id"] = str(existing_retriever_id)
-
-        files: List[tuple[str, io.BufferedReader | bytes]] = []
-        if template_file:
-            if isinstance(template_file, str):
-                open_files.append(open(template_file, "rb"))
-                files.append(("template_file", open_files[-1]))
-            else:
-                files.append(("template_file", template_file[1]))
-
-        if input_files:
-            for f in input_files:
-                if isinstance(f, str):
-                    open_files.append(open(f, "rb"))
-                    files.append(("files", open_files[-1]))
-                else:
-                    files.append(("files", f[1]))
-
-        response = await self.aclient.post(
-            url, headers=self.headers, data=data, files=files
-        )
-        try:
-            response.raise_for_status()
-            report_id = response.json()["id"]
-            return ReportClient(report_id, name, self)
-        except httpx.HTTPStatusError as e:
-            raise ValueError(
-                f"Failed to create report: {e.response.text}\nError Code: {e.response.status_code}"
-            )
-        finally:
-            for open_file in open_files:
-                open_file.close()
-
-    def create_report(
-        self,
-        name: str,
-        template_instructions: Optional[str] = None,
-        template_text: Optional[str] = None,
-        template_file: Optional[Union[str, tuple[str, bytes]]] = None,
-        input_files: Optional[List[Union[str, tuple[str, bytes]]]] = None,
-        existing_retriever_id: Optional[str] = None,
-    ) -> ReportClient:
-        """Create a new report."""
-        return self._run_sync(
-            self.acreate_report(
-                name=name,
-                template_instructions=template_instructions,
-                template_text=template_text,
-                template_file=template_file,
-                input_files=input_files,
-                existing_retriever_id=existing_retriever_id,
-            )
-        )
-
-    async def alist_reports(
-        self, state: Optional[str] = None, limit: int = 100, offset: int = 0
-    ) -> List[ReportClient]:
-        """List all reports asynchronously."""
-        params = []
-        if state:
-            params.append(f"state={state}")
-        if limit:
-            params.append(f"limit={limit}")
-        if offset:
-            params.append(f"offset={offset}")
-
-        url = await self._build_url(
-            "/api/v1/reports/list",
-            extra_params=params,
-        )
-
-        response = await self.aclient.get(url, headers=self.headers)
-        response.raise_for_status()
-        data = response.json()
-
-        return [
-            ReportClient(r["report_id"], r["name"], self)
-            for r in data["report_responses"]
-        ]
-
-    def list_reports(
-        self, state: Optional[str] = None, limit: int = 100, offset: int = 0
-    ) -> List[ReportClient]:
-        """Synchronous wrapper for listing reports."""
-        return self._run_sync(self.alist_reports(state, limit, offset))
-
-    async def aget_report(self, report_id: str) -> ReportClient:
-        """Get a Report instance for working with a specific report."""
-        url = await self._build_url(f"/api/v1/reports/{report_id}")
-
-        response = await self.aclient.get(url, headers=self.headers)
-        response.raise_for_status()
-        data = response.json()
-
-        return ReportClient(data["report_id"], data["name"], self)
-
-    def get_report(self, report_id: str) -> ReportClient:
-        """Synchronous wrapper for getting a report."""
-        return self._run_sync(self.aget_report(report_id))
-
-    async def aget_report_metadata(self, report_id: str) -> ReportMetadata:
-        """Get metadata for a specific report asynchronously.
-
-        Returns:
-            dict containing:
-            - id: Report ID
-            - name: Report name
-            - state: Current report state
-            - report_metadata: Additional metadata
-            - template_file: Name of template file if used
-            - template_instructions: Template instructions if provided
-            - input_files: List of input file names
-        """
-        url = await self._build_url(f"/api/v1/reports/{report_id}/metadata")
-
-        response = await self.aclient.get(url, headers=self.headers)
-        response.raise_for_status()
-        return ReportMetadata(**response.json())
-
-    def get_report_metadata(self, report_id: str) -> ReportMetadata:
-        """Synchronous wrapper for getting report metadata."""
-        return self._run_sync(self.aget_report_metadata(report_id))
-
-    async def adelete_report(self, report_id: str) -> None:
-        """Delete a specific report asynchronously."""
-        url = await self._build_url(f"/api/v1/reports/{report_id}")
-
-        response = await self.aclient.delete(url, headers=self.headers)
-        response.raise_for_status()
-
-    def delete_report(self, report_id: str) -> None:
-        """Synchronous wrapper for deleting a report."""
-        return self._run_sync(self.adelete_report(report_id))
@@ -1,527 +0,0 @@
-import asyncio
-import httpx
-import time
-from typing import Optional, List, Literal, Union, TYPE_CHECKING
-from dataclasses import dataclass
-from datetime import datetime
-from enum import Enum
-
-from llama_cloud.types import (
-    ReportEventItemEventData_Progress,
-    ReportMetadata,
-    EditSuggestion,
-    ReportResponse,
-    ReportPlan,
-    ReportBlock,
-    ReportPlanBlock,
-    Report,
-)
-
-if TYPE_CHECKING:
-    from llama_cloud_services.report.base import LlamaReport
-
-
-class MessageRole(str, Enum):
-    USER = "user"
-    ASSISTANT = "assistant"
-
-
-@dataclass
-class Message:
-    role: MessageRole
-    content: str
-    timestamp: datetime
-
-
-@dataclass
-class EditAction:
-    block_idx: int
-    old_content: str
-    new_content: Optional[str]
-    action: Literal["approved", "rejected"]
-    timestamp: datetime
-
-
-DEFAULT_POLL_INTERVAL = 5
-DEFAULT_TIMEOUT = 600
-
-
-class ReportClient:
-    """Client for operations on a specific report."""
-
-    def __init__(self, report_id: str, name: str, parent_client: "LlamaReport"):
-        self.report_id = report_id
-        self.name = name
-        self._client = parent_client
-        self._headers = parent_client.headers
-        self._run_sync = parent_client._run_sync
-        self._build_url = parent_client._build_url
-        self.chat_history: List[Message] = []
-        self.edit_history: List[EditAction] = []
-
-    @property
-    def aclient(self) -> httpx.AsyncClient:
-        return self._client.aclient
-
-    def __str__(self) -> str:
-        return f"Report(id={self.report_id}, name={self.name})"
-
-    def __repr__(self) -> str:
-        return f"Report(id={self.report_id}, name={self.name})"
-
-    def _get_block_content(self, block: Union[ReportBlock, ReportPlanBlock]) -> str:
-        if isinstance(block, ReportBlock):
-            return block.template
-        elif isinstance(block, ReportPlanBlock):
-            return block.block.template
-        else:
-            raise ValueError(f"Invalid block type: {type(block)}")
-
-    def _get_block_idx(self, block: Union[ReportBlock, ReportPlanBlock]) -> int:
-        if isinstance(block, ReportBlock):
-            return block.idx
-        elif isinstance(block, ReportPlanBlock):
-            return block.block.idx
-        else:
-            raise ValueError(f"Invalid block type: {type(block)}")
-
-    async def aget(self, version: Optional[int] = None) -> ReportResponse:
-        """Get this report's details asynchronously."""
-        extra_params = []
-        if version is not None:
-            extra_params.append(f"version={version}")
-
-        url = await self._build_url(f"/api/v1/reports/{self.report_id}", extra_params)
-
-        response = await self.aclient.get(url, headers=self._headers)
-        response.raise_for_status()
-        return ReportResponse(**response.json())
-
-    def get(self, version: Optional[int] = None) -> ReportResponse:
-        """Synchronous wrapper for getting this report's details."""
-        return self._run_sync(self.aget(version))
-
-    async def aupdate_report(self, updated_report: Report) -> ReportResponse:
-        """Update this report's content asynchronously."""
-        url = await self._build_url(f"/api/v1/reports/{self.report_id}")
-        response = await self.aclient.patch(
-            url, headers=self._headers, json={"content": updated_report.dict()}
-        )
-        response.raise_for_status()
-        return ReportResponse(**response.json())
-
-    def update_report(self, updated_report: Report) -> ReportResponse:
-        """Synchronous wrapper for updating this report's content."""
-        return self._run_sync(self.aupdate_report(updated_report))
-
-    async def aupdate_plan(
-        self,
-        action: Literal["approve", "reject", "edit"],
-        updated_plan: Optional[ReportPlan] = None,
-    ) -> ReportResponse:
-        """Update this report's plan asynchronously."""
-        if action == "edit" and not updated_plan:
-            raise ValueError("updated_plan is required when action is 'edit'")
-
-        url = await self._build_url(
-            f"/api/v1/reports/{self.report_id}/plan", [f"action={action}"]
-        )
-
-        data = None
-        if updated_plan is not None:
-            plan_dict = updated_plan.dict()
-            plan_dict.pop("generated_at", None)
-            data = plan_dict
-
-        if updated_plan is None and action == "edit":
-            raise ValueError("updated_plan is required when action is 'edit'")
-
-        response = await self.aclient.patch(url, headers=self._headers, json=data)
-        response.raise_for_status()
-        return ReportResponse(**response.json())
-
-    def update_plan(
-        self,
-        action: Literal["approve", "reject", "edit"],
-        updated_plan: Optional[ReportPlan] = None,
-    ) -> ReportResponse:
-        """Synchronous wrapper for updating this report's plan."""
-        return self._run_sync(self.aupdate_plan(action, updated_plan))
-
-    async def asuggest_edits(
-        self,
-        user_query: str,
-        auto_history: bool = True,
-        chat_history: Optional[List[dict]] = None,
-    ) -> List[EditSuggestion]:
-        """Get AI suggestions for edits to this report asynchronously.
-
-        Args:
-            user_query: The user's request/question about what to edit
-            auto_history: Whether to automatically add the user's message to the chat history
-            chat_history:
-                A list of chat messages to include in the chat history.
-                The format being a list of dictionaries with "role" and "content" keys.
-        """
-        # Add user message to history
-        self.chat_history.append(
-            Message(role=MessageRole.USER, content=user_query, timestamp=datetime.now())
-        )
-
-        # Format chat history with edit summaries
-        chat_history_dicts = []
-        for msg in self.chat_history[:-1]:  # Exclude current message
-            content = msg.content
-            if msg.role == MessageRole.USER:
-                # Add edit summary for user messages
-                edit_summary = self._get_edit_summary_after_message(msg.timestamp)
-                if edit_summary:
-                    content = f"{content}\n\nActions taken:\n{edit_summary}"
-
-            chat_history_dicts.append({"role": msg.role.value, "content": content})
-
-        # decide whether to include chat history or not
-        if chat_history:
-            chat_history_dicts = chat_history
-        elif auto_history:
-            chat_history_dicts = chat_history_dicts
-        else:
-            chat_history_dicts = []
-
-        # Make the API call
-        url = await self._build_url(f"/api/v1/reports/{self.report_id}/suggest_edits")
-        data = {"user_query": user_query, "chat_history": chat_history_dicts}
-
-        response = await self.aclient.post(url, headers=self._headers, json=data)
-        response.raise_for_status()
-        suggestions = response.json()
-        suggestions = [EditSuggestion(**suggestion) for suggestion in suggestions]
-
-        # Add assistant response to history
-        if suggestions:
-            for suggestion in suggestions:
-                self.chat_history.append(
-                    Message(
-                        role=MessageRole.ASSISTANT,
-                        content=suggestion.justification,
-                        timestamp=datetime.now(),
-                    )
-                )
-
-        return suggestions
-
-    def suggest_edits(
-        self,
-        user_query: str,
-        auto_history: bool = True,
-        chat_history: Optional[List[dict]] = None,
-    ) -> List[EditSuggestion]:
-        """Synchronous wrapper for getting edit suggestions."""
-        return self._run_sync(
-            self.asuggest_edits(user_query, auto_history, chat_history)
-        )
-
-    async def await_completion(
-        self, timeout: int = DEFAULT_TIMEOUT, poll_interval: int = DEFAULT_POLL_INTERVAL
-    ) -> Report:
-        """Wait for this report to complete processing."""
-        start_time = time.time()
-        while True:
-            report_response = await self.aget()
-            status = report_response.status
-
-            if status == "completed":
-                return report_response.report
-            elif status == "error":
-                events = await self.aget_events()
-                raise ValueError(f"Report entered error state: {events[-1].msg}")
-            elif time.time() - start_time > timeout:
-                raise TimeoutError(f"Report did not complete within {timeout} seconds")
-
-            await asyncio.sleep(poll_interval)
-
-    def wait_for_completion(
-        self, timeout: int = DEFAULT_TIMEOUT, poll_interval: int = DEFAULT_POLL_INTERVAL
-    ) -> Report:
-        """Synchronous wrapper for awaiting report completion."""
-        return self._run_sync(self.await_completion(timeout, poll_interval))
-
-    async def await_for_plan(
-        self, timeout: int = DEFAULT_TIMEOUT, poll_interval: int = DEFAULT_POLL_INTERVAL
-    ) -> ReportPlan:
-        """Wait for this report's plan to be ready for review."""
-        start_time = time.time()
-        while True:
-            report_metadata = await self.aget_metadata()
-            state = report_metadata.state
-
-            if state == "waiting_approval":
-                report_response = await self.aget()
-                return report_response.plan
-            elif state == "error":
-                events = await self.aget_events()
-                raise ValueError(f"Report entered error state: {events[-1].msg}")
-            elif time.time() - start_time > timeout:
-                raise TimeoutError(f"Plan was not ready within {timeout} seconds")
-
-            await asyncio.sleep(poll_interval)
-
-    def wait_for_plan(
-        self, timeout: int = DEFAULT_TIMEOUT, poll_interval: int = DEFAULT_POLL_INTERVAL
-    ) -> ReportPlan:
-        """Synchronous wrapper for awaiting plan readiness."""
-        return self._run_sync(self.await_for_plan(timeout, poll_interval))
-
-    async def aget_metadata(self) -> ReportMetadata:
-        """Get this report's metadata asynchronously."""
-        return await self._client.aget_report_metadata(self.report_id)
-
-    def get_metadata(self) -> ReportMetadata:
-        """Synchronous wrapper for getting this report's metadata."""
-        return self._run_sync(self.aget_metadata())
-
-    async def adelete(self) -> None:
-        """Delete this report asynchronously."""
-        return await self._client.adelete_report(self.report_id)
-
-    def delete(self) -> None:
-        """Synchronous wrapper for deleting this report."""
-        return self._run_sync(self.adelete())
-
-    async def aaccept_edit(self, suggestion: EditSuggestion) -> None:
-        """Accept a suggested edit.
-
-        Args:
-            suggestion: The EditSuggestion to accept, typically from suggest_edits()
-        """
-        if len(suggestion.blocks) == 0:
-            return
-
-        # Determine if we're editing a plan or report based on first block type
-        is_plan_edit = isinstance(suggestion.blocks[0], ReportPlanBlock)
-
-        # Get current content
-        report_response = await self.aget()
-        current_blocks = (
-            report_response.plan.blocks
-            if is_plan_edit
-            else report_response.report.blocks
-        )
-
-        # Track the edit
-        new_blocks = []
-        for edit_block in suggestion.blocks:
-            # Find matching block in current content
-            old_block = next(
-                (
-                    b
-                    for b in current_blocks
-                    if self._get_block_idx(b) == self._get_block_idx(edit_block)
-                ),
-                None,
-            )
-
-            old_content = (
-                self._get_block_content(old_block) if old_block else "[No old content]"
-            )
-            new_content = self._get_block_content(edit_block)
-
-            if is_plan_edit:
-                new_queries_str = "\n".join(
-                    [
-                        f"Field: {q.field}, Prompt: {q.prompt}, Context: {q.context}"
-                        for q in edit_block.queries
-                    ]
-                )
-                new_dependency_str = (
-                    f"Depends on: {edit_block.dependency}"
-                    if edit_block.dependency
-                    else ""
-                )
-                new_content += f"\n\n{new_queries_str}\n{new_dependency_str}"
-
-                if old_block:
-                    old_queries_str = "\n".join(
-                        [
-                            f"Field: {q.field}, Prompt: {q.prompt}, Context: {q.context}"
-                            for q in old_block.queries
-                        ]
-                    )
-                    old_dependency_str = (
-                        f"Depends on: {old_block.dependency}"
-                        if old_block.dependency
-                        else ""
-                    )
-                    old_content += f"\n\n{old_queries_str}\n{old_dependency_str}"
-
-            self.edit_history.append(
-                EditAction(
-                    block_idx=self._get_block_idx(edit_block),
-                    old_content=old_content,
-                    new_content=new_content,
-                    action="approved",
-                    timestamp=datetime.now(),
-                )
-            )
-
-            # Create updated block
-            if is_plan_edit:
-                new_blocks.append(
-                    ReportPlanBlock(
-                        block=ReportBlock(
-                            idx=edit_block.block.idx,
-                            template=self._get_block_content(edit_block),
-                            sources=edit_block.block.sources,
-                        ),
-                        queries=edit_block.queries,
-                        dependency=edit_block.dependency,
-                    )
-                )
-            else:
-                new_blocks.append(
-                    ReportBlock(
-                        idx=edit_block.idx,
-                        template=self._get_block_content(edit_block),
-                        sources=edit_block.sources,
-                    )
-                )
-
-        if new_blocks:
-            if is_plan_edit:
-                # Update plan in place
-                plan = report_response.plan
-
-                # Replace edited blocks and add new ones
-                for new_block in new_blocks:
-                    block_idx = self._get_block_idx(new_block)
-                    existing_block_idx = next(
-                        (
-                            i
-                            for i, b in enumerate(plan.blocks)
-                            if b.block.idx == block_idx
-                        ),
-                        None,
-                    )
-
-                    if existing_block_idx is not None:
-                        # Replace existing block
-                        plan.blocks[existing_block_idx] = new_block
-                    else:
-                        # Add new block to end
-                        plan.blocks.append(new_block)
-
-                await self.aupdate_plan("edit", plan)
-            else:
-                # Update report in place
-                report = report_response.report
-
-                # Replace edited blocks and add new ones
-                for new_block in new_blocks:
-                    block_idx = self._get_block_idx(new_block)
-                    existing_block_idx = next(
-                        (i for i, b in enumerate(report.blocks) if b.idx == block_idx),
-                        None,
-                    )
-
-                    if existing_block_idx is not None:
-                        # Replace existing block
-                        report.blocks[existing_block_idx] = new_block
-                    else:
-                        # Add new block to end
-                        report.blocks.append(new_block)
-
-                await self.aupdate_report(report)
-
-    def accept_edit(self, suggestion: EditSuggestion) -> None:
-        """Synchronous wrapper for accepting an edit."""
-        return self._run_sync(self.aaccept_edit(suggestion))
-
-    async def areject_edit(self, suggestion: EditSuggestion) -> None:
-        """Reject a suggested edit.
-
-        Args:
-            suggestion: The EditSuggestion to reject, typically from suggest_edits()
-        """
-        # Track the rejections
-        for edit_block in suggestion.blocks:
-            self.edit_history.append(
-                EditAction(
-                    block_idx=self._get_block_idx(edit_block),
-                    old_content=self._get_block_content(edit_block),
-                    new_content=None,
-                    action="rejected",
-                    timestamp=datetime.now(),
-                )
-            )
-
-    def reject_edit(self, suggestion: EditSuggestion) -> None:
-        """Synchronous wrapper for rejecting an edit."""
-        return self._run_sync(self.areject_edit(suggestion))
-
-    def _get_edit_summary_after_message(
-        self, message_timestamp: datetime
-    ) -> Optional[str]:
-        """Get a summary of edits that occurred after a specific message."""
-        relevant_edits = [
-            edit for edit in self.edit_history if edit.timestamp > message_timestamp
-        ]
-
-        if not relevant_edits:
-            return None
-
-        approved = [edit for edit in relevant_edits if edit.action == "approved"]
-        rejected = [edit for edit in relevant_edits if edit.action == "rejected"]
-
-        summary = []
-
-        if approved:
-            summary.append("Approved edits:")
-            for edit in approved:
-                summary.append(
-                    f'Block {edit.block_idx}: "{edit.old_content}" -> "{edit.new_content}"'
-                )
-
-        if rejected:
-            if approved:  # Add spacing if we had approved edits
-                summary.append("")
-            summary.append("Rejected edits:")
-            for edit in rejected:
-                summary.append(f'Block {edit.block_idx}: "{edit.old_content}"')
-
-        return "\n".join(summary)
-
-    async def aget_events(
-        self, last_sequence: Optional[int] = None
-    ) -> List[ReportEventItemEventData_Progress]:
-        """Get all events for this report asynchronously.
-
-        Args:
-            last_sequence: If provided, only get events after this sequence number
-
-        Returns:
-            List of ReportEvent objects
-        """
-        extra_params = []
-        if last_sequence is not None:
-            extra_params.append(f"last_sequence={last_sequence}")
-
-        url = await self._build_url(
-            f"/api/v1/reports/{self.report_id}/events", extra_params
-        )
-
-        response = await self.aclient.get(url, headers=self._headers)
-        response.raise_for_status()
-        progress_events = []
-        for event in response.json():
-            if event["event_type"] == "progress":
-                progress_events.append(
-                    ReportEventItemEventData_Progress(**event["event_data"])
-                )
-
-        return progress_events
-
-    def get_events(
-        self, last_sequence: Optional[int] = None
-    ) -> List[ReportEventItemEventData_Progress]:
-        """Synchronous wrapper for getting report events."""
-        return self._run_sync(self.aget_events(last_sequence))
@@ -11,13 +11,13 @@ dev = [

 [project]
 name = "llama-parse"
-version = "0.6.63"
+version = "0.6.65"
 description = "Parse files into RAG-Optimized formats."
 authors = [{name = "Logan Markewich", email = "logan@llamaindex.ai"}]
 requires-python = ">=3.9,<4.0"
 readme = "README.md"
 license = "MIT"
-dependencies = ["llama-cloud-services>=0.6.63"]
+dependencies = ["llama-cloud-services>=0.6.64"]

 [project.scripts]
 llama-parse = "llama_parse.cli.main:parse"
@@ -19,7 +19,7 @@ dev = [

 [project]
 name = "llama-cloud-services"
-version = "0.6.63"
+version = "0.6.65"
 description = "Tailored SDK clients for LlamaCloud services."
 authors = [{name = "Logan Markewich", email = "logan@runllama.ai"}]
 requires-python = ">=3.9,<4.0"
@@ -27,7 +27,7 @@ readme = "README.md"
 license = "MIT"
 dependencies = [
  "llama-index-core>=0.12.0",
-  "llama-cloud==0.1.37",
+  "llama-cloud==0.1.41",
  "pydantic>=2.8,!=2.10",
  "click>=8.1.7,<9",
  "python-dotenv>=1.0.1,<2",
@@ -2,6 +2,7 @@ import os
 import pytest
 import shutil
 from typing import Optional, cast
+from unittest.mock import patch
 from fsspec.implementations.local import LocalFileSystem
 from httpx import AsyncClient

@@ -204,6 +205,10 @@ async def test_get_result(markdown_parser: LlamaParse) -> None:
    assert len(result.pages) == len(expected.pages)


+@pytest.mark.skipif(
+    os.environ.get("LLAMA_CLOUD_API_KEY", "") == "",
+    reason="LLAMA_CLOUD_API_KEY not set",
+)
@pytest.mark.asyncio
 async def test_parse_audio() -> None:
    parser = LlamaParse()
@@ -211,3 +216,194 @@ async def test_parse_audio() -> None:

    result = await parser.aparse(filepath)
    assert result.job_id is not None
+
+
+@pytest.mark.asyncio
+async def test_error_handling_with_raise_job_error_false() -> None:
+    """Test that failed jobs return JobResult objects with error information when raise_job_error=False."""
+
+    parser = LlamaParse(api_key="test_key")
+
+    # Mock error result with full error information
+    mock_error_result = {
+        "pages": [],
+        "job_metadata": {"job_pages": 0},
+        "error": "Job ID: test_job_123 failed with status: ERROR, Error code: INVALID_FILE, Error message: File format not supported",
+        "status": "ERROR",
+    }
+
+    with patch.object(parser, "_create_job", return_value="test_job_123"), patch.object(
+        parser, "_get_job_result", return_value=mock_error_result
+    ):
+        # Test aparse with raise_job_error=False
+        result = await parser.aparse("test_file.txt", raise_job_error=False)
+
+        assert isinstance(result, type(result))  # Check it's a JobResult
+        assert result.job_id == "test_job_123"
+        assert result.error is not None
+        assert "ERROR" in result.error
+        assert "INVALID_FILE" in result.error
+        assert "File format not supported" in result.error
+        assert len(result.pages) == 0
+
+        # Test parse (synchronous version) with raise_job_error=False
+        result_sync = parser.parse("test_file.txt", raise_job_error=False)
+
+        assert isinstance(result_sync, type(result_sync))
+        assert result_sync.job_id == "test_job_123"
+        assert result_sync.error is not None
+        assert "INVALID_FILE" in result_sync.error
+        assert "File format not supported" in result_sync.error
+
+
+@pytest.mark.asyncio
+async def test_error_handling_with_raise_job_error_true() -> None:
+    """Test that failed jobs raise JobFailedException when raise_job_error=True (default behavior)."""
+
+    parser = LlamaParse(api_key="test_key")
+
+    # Mock that _get_job_result will raise JobFailedException when raise_job_error=True
+    from llama_cloud_services.parse.base import JobFailedException
+
+    def mock_get_job_result(job_id, result_type, verbose=False, raise_job_error=True):
+        if raise_job_error:
+            raise JobFailedException(
+                "test_job_123",
+                "ERROR",
+                error_code="INVALID_FILE",
+                error_message="File format not supported",
+            )
+        else:
+            return {
+                "pages": [],
+                "job_metadata": {"job_pages": 0},
+                "error": "Job ID: test_job_123 failed with status: ERROR, Error code: INVALID_FILE, Error message: File format not supported",
+                "status": "ERROR",
+            }
+
+    with patch.object(parser, "_create_job", return_value="test_job_123"), patch.object(
+        parser, "_get_job_result", side_effect=mock_get_job_result
+    ):
+        # Test aparse with raise_job_error=True (default) - should raise exception
+        with pytest.raises(JobFailedException) as exc_info:
+            await parser.aparse("test_file.txt")
+
+        assert exc_info.value.job_id == "test_job_123"
+        assert exc_info.value.status == "ERROR"
+        assert exc_info.value.error_code == "INVALID_FILE"
+
+        # Test parse (synchronous version) with raise_job_error=True (default) - should raise exception
+        with pytest.raises(JobFailedException) as exc_info:
+            parser.parse("test_file.txt")
+
+        assert exc_info.value.job_id == "test_job_123"
+        assert exc_info.value.status == "ERROR"
+
+
+@pytest.mark.asyncio
+async def test_error_handling_with_minimal_fields() -> None:
+    """Test error handling when only status is available (no error_code/error_message) with raise_job_error=False."""
+
+    parser = LlamaParse(api_key="test_key")
+
+    # Mock error result with minimal fields (only what's guaranteed)
+    mock_minimal_error_result = {
+        "pages": [],
+        "job_metadata": {"job_pages": 0},
+        "error": "Job ID: test_job_456 failed with status: CANCELED",
+        "status": "CANCELED",
+    }
+
+    with patch.object(parser, "_create_job", return_value="test_job_456"), patch.object(
+        parser, "_get_job_result", return_value=mock_minimal_error_result
+    ):
+        # Test aparse with a minimal error response and raise_job_error=False
+        result = await parser.aparse("test_file.txt", raise_job_error=False)
+
+        assert isinstance(result, type(result))
+        assert result.job_id == "test_job_456"
+        assert result.error is not None
+        assert "CANCELED" in result.error
+        assert len(result.pages) == 0
+
+
+@pytest.mark.asyncio
+async def test_successful_job_still_works() -> None:
+    """Test that successful jobs still work as before after error handling changes."""
+
+    parser = LlamaParse(api_key="test_key")
+
+    # Mock successful result
+    mock_success_result = {
+        "pages": [
+            {
+                "page": 0,
+                "text": "Sample text content",
+                "md": "# Sample markdown content",
+                "images": [],
+                "charts": [],
+                "tables": [],
+                "layout": [],
+                "items": [],
+                "status": "SUCCESS",
+                "links": [],
+                "width": 612.0,
+                "height": 792.0,
+            }
+        ],
+        "job_metadata": {"job_pages": 1},
+    }
+
+    with patch.object(
+        parser, "_create_job", return_value="success_job_456"
+    ), patch.object(parser, "_get_job_result", return_value=mock_success_result):
+        # Test aparse with a successful job (both with and without raise_job_error parameter)
+        result = await parser.aparse("test_file.txt")
+
+        assert isinstance(result, type(result))
+        assert result.job_id == "success_job_456"
+        assert result.error is None  # No error for successful jobs
+        assert len(result.pages) == 1
+        assert result.pages[0].text == "Sample text content"
+
+        # Test with explicit raise_job_error=False (should work the same for successful jobs)
+        result2 = await parser.aparse("test_file.txt", raise_job_error=False)
+
+        assert isinstance(result2, type(result2))
+        assert result2.job_id == "success_job_456"
+        assert result2.error is None
+        assert len(result2.pages) == 1
+        assert result2.pages[0].text == "Sample text content"
+
+
+@pytest.mark.asyncio
+async def test_get_result_with_raise_job_error_parameter() -> None:
+    """Test that get_result method respects the raise_job_error parameter."""
+
+    parser = LlamaParse(api_key="test_key")
+
+    # Mock error result
+    mock_error_result = {
+        "pages": [],
+        "job_metadata": {"job_pages": 0},
+        "error": "Job ID: test_job_789 failed with status: ERROR, Error code: TIMEOUT, Error message: Job timed out",
+        "status": "ERROR",
+    }
+
+    with patch.object(parser, "_get_job_result", return_value=mock_error_result):
+        # Test aget_result with raise_job_error=False
+        result = await parser.aget_result("test_job_789", raise_job_error=False)
+
+        assert isinstance(result, type(result))
+        assert result.job_id == "test_job_789"
+        assert result.error is not None
+        assert "TIMEOUT" in result.error
+        assert len(result.pages) == 0
+
+        # Test get_result (synchronous version) with raise_job_error=False
+        result_sync = parser.get_result("test_job_789", raise_job_error=False)
+
+        assert isinstance(result_sync, type(result_sync))
+        assert result_sync.job_id == "test_job_789"
+        assert result_sync.error is not None
+        assert "TIMEOUT" in result_sync.error
@@ -1,129 +0,0 @@
-import os
-import pytest
-import uuid
-from typing import AsyncGenerator
-from pytest_asyncio import fixture as async_fixture
-from llama_cloud_services.report import LlamaReport, ReportClient
-
-# Skip tests if no API key is set
-pytestmark = pytest.mark.skipif(
-    not os.getenv("LLAMA_CLOUD_API_KEY") or os.getenv("CI") == "true",
-    reason="No API key provided",
-)
-
-
-@async_fixture(scope="function")
-async def client() -> AsyncGenerator[LlamaReport, None]:
-    """Create a LlamaReport client."""
-    client = LlamaReport()
-    reports_before = await client.alist_reports()
-    reports_before_ids = [r.report_id for r in reports_before]
-    try:
-        yield client
-    finally:
-        # clean up reports
-        try:
-            reports_after = await client.alist_reports()
-            reports_after_ids = [r.report_id for r in reports_after]
-            for report_id in reports_before_ids:
-                if report_id not in reports_after_ids:
-                    await client.adelete_report(report_id)
-        except Exception:
-            pass
-        finally:
-            await client.aclient.aclose()
-
-
-@pytest.fixture(scope="function")
-def unique_name() -> str:
-    """Generate a unique report name."""
-    return f"test-report-{uuid.uuid4()}"
-
-
-@async_fixture(scope="function")
-async def report(
-    client: LlamaReport, unique_name: str
-) -> AsyncGenerator[ReportClient, None]:
-    """Create a report."""
-    report = await client.acreate_report(
-        name=unique_name,
-        template_text=(
-            "# [Some title]\n\n"
-            " ## TLDR\n"
-            "A quick summary of the paper.\n\n"
-            "## Details\n"
-            "More details about the paper, possible more than one section here.\n"
-        ),
-        input_files=["tests/test_files/paper.md"],
-    )
-    try:
-        yield report
-    finally:
-        await report.adelete()
-
-
-@pytest.mark.asyncio
-@pytest.mark.xfail(
-    condition=lambda: os.getenv("CI"),
-    reason="Backend db issues; needs to be fixed.",
-)
-async def test_create_and_delete_report(
-    client: LlamaReport, report: ReportClient
-) -> None:
-    """Test basic report creation and deletion."""
-    # Verify the report exists
-    metadata = await report.aget_metadata()
-    assert metadata.name == report.name
-
-    # Test listing reports
-    reports = await client.alist_reports()
-    assert any(r.report_id == report.report_id for r in reports)
-
-    # Test getting report by ID
-    fetched_report = await client.aget_report(report.report_id)
-    assert fetched_report.report_id == report.report_id
-    assert fetched_report.name == report.name
-
-
-@pytest.mark.asyncio
-@pytest.mark.xfail(
-    condition=lambda: os.getenv("CI"),
-    reason="Report plan sometimes times out",
-    raises=TimeoutError,
-)
-async def test_report_plan_workflow(report: ReportClient) -> None:
-    """Test the report planning workflow."""
-    # Wait for the plan
-    plan = await report.await_for_plan()
-    assert plan is not None
-
-    # Approve the plan
-    response = await report.aupdate_plan(action="approve")
-    assert response is not None
-
-    # Wait for completion
-    completed_report = await report.await_completion()
-    assert len(completed_report.blocks) > 0
-
-    # Get edit suggestions
-    suggestions = await report.asuggest_edits(
-        "TLDR section header more formal.", auto_history=True
-    )
-    assert len(suggestions) > 0
-
-    # Test accepting an edit
-    await report.aaccept_edit(suggestions[0])
-
-    # Get more suggestions and test rejecting
-    more_suggestions = await report.asuggest_edits(
-        "Add a section about machine learning.", auto_history=True
-    )
-    assert len(more_suggestions) > 0
-    await report.areject_edit(more_suggestions[0])
-
-    # Verify chat history is maintained
-    assert len(report.chat_history) >= 4  # 2 user messages + 2 assistant responses
-
-    # get events
-    events = await report.aget_events()
-    assert len(events) > 0
@@ -1,101 +0,0 @@
-# LlamaReport (beta/invite-only)
-
-LlamaReport is a prebuilt agentic report builder that can be used to build reports from a variety of data sources.
-
-The python SDK for interacting with the LlamaReport API. The SDK provides two main classes:
-
- `LlamaReport`: For managing reports (create, list, delete)
- `ReportClient`: For working with a specific report (editing, approving, etc.)
-
-## Quickstart
-
-```bash
-pip install llama-cloud-services
-```
-
-```python
-from llama_cloud_services import LlamaReport
-
-# Initialize the client
-client = LlamaReport(
-    api_key="your-api-key",
-    # Optional: Specify project_id, organization_id, async_httpx_client
-)
-
-# Create a new report
-report = client.create_report(
-    "My Report",
-    # must have one of template_text or template_instructions
-    template_text="Your template text",
-    template_instructions="Instructions for the template",
-    # must have one of input_files or retriever_id
-    input_files=["data1.pdf", "data2.pdf"],
-    retriever_id="retriever-id",
-)
-```
-
-## Working with Reports
-
-The typical workflow for a report involves:
-
-1. Creating the report
-2. Waiting for and approving the plan
-3. Waiting for report generation
-4. Making edits to the report
-
-Here's a complete example:
-
-```python
-# Create a report
-report = client.create_report(
-    "Quarterly Analysis", input_files=["q1_data.pdf", "q2_data.pdf"]
-)
-
-# Wait for the plan to be ready
-plan = report.wait_for_plan()
-
-# Option 1: Directly approve the plan
-report.update_plan(action="approve")
-
-# Option 2: Suggest and review edits to the plan
-suggestions = report.suggest_edits(
-    "Can you add a section about market trends?"
-)
-for suggestion in suggestions:
-    print(suggestion)
-
-    # Accept or reject the suggestion
-    if input("Accept? (y/n): ").lower() == "y":
-        report.accept_edit(suggestion)
-    else:
-        report.reject_edit(suggestion)
-
-# Wait for the report to complete
-report = report.wait_for_completion()
-
-# Make edits to the final report
-suggestions = report.suggest_edits("Make the executive summary more concise")
-
-# Review and accept/reject suggestions as above
-...
-```
-
-### Getting the Final Report
-
-Once you are satisfied with the report, you can get the final report object and use the content as you see fit.
-
-Here's an example of printing out the final report:
-
-```python
-report = report.get()
-report_text = "\n\n".join([block.template for block in report.blocks])
-
-print(report_text)
-```
-
-## Additional Features
-
- **Async Support**: All methods have async counterparts: `create_report` -> `acreate_report`, `wait_for_plan` -> `await_for_plan`, etc.
- **Automatic Chat History**: The SDK automatically keeps track of chat history for each suggestion, unless you specify `auto_history=False` in `suggest_edits`.
- **Custom HTTP Client**: You can provide your own `httpx.AsyncClient` to the `LlamaReport` class.
- **Project and Organization IDs**: You can specify `project_id` and `organization_id` to use a specific project or organization.
@@ -8,10 +8,11 @@ import subprocess
 import sys
 import tomlkit
 from pathlib import Path
+import json


-def get_current_versions() -> tuple[str, str, str]:
-    """Get current versions from both pyproject.toml files."""
+def get_current_versions() -> tuple[str, str, str, str | None]:
+    """Get current versions from both pyproject.toml files and TS package.json."""
    # Read main pyproject.toml
    main_content = Path("py/pyproject.toml").read_text()
    main_doc = tomlkit.parse(main_content)
@@ -34,11 +35,21 @@ def get_current_versions() -> tuple[str, str, str]:
            )
            break

-    return str(main_version), str(llama_parse_version), str(dependency_version)
+    # Read TypeScript package.json version via helper
+    ts_version: str = get_ts_version()
+
+    return (
+        str(main_version),
+        str(llama_parse_version),
+        str(dependency_version),
+        str(ts_version) if ts_version is not None else None,
+    )


 def validate_versions(
-    main_version: str, llama_parse_version: str, dependency_version: str
+    main_version: str,
+    llama_parse_version: str,
+    dependency_version: str,
 ) -> list[str]:
    """Validate that versions are consistent and return warnings."""
    warnings = []
@@ -60,7 +71,7 @@ def validate_versions(


 def set_version(version: str) -> None:
-    """Set version across all pyproject.toml files using tomlkit to preserve formatting."""
+    """Set version across Python projects (no TS change)."""
    # Update main pyproject.toml
    main_content = Path("py/pyproject.toml").read_text()
    main_doc = tomlkit.parse(main_content)
@@ -79,7 +90,26 @@ def set_version(version: str) -> None:
            break
    Path("py/llama_parse/pyproject.toml").write_text(tomlkit.dumps(llama_parse_doc))

-    click.echo(f"Updated all versions to {version}")
+    click.echo(f"Updated Python versions to {version}")
+
+
+def get_ts_version() -> str:
+    """Read TypeScript package.json version (if present)."""
+    ts_package_path = Path("ts/llama_cloud_services/package.json")
+    package_data = json.loads(ts_package_path.read_text())
+    data = package_data.get("version")
+    if data is None:
+        raise RuntimeError("TypeScript package.json version not found")
+    return data
+
+
+def set_ts_version(version: str) -> None:
+    """Set TypeScript package.json version only."""
+    ts_package_path = Path("ts/llama_cloud_services/package.json")
+    package_data = json.loads(ts_package_path.read_text())
+    package_data["version"] = version
+    ts_package_path.write_text(json.dumps(package_data, indent=2) + "\n")
+    click.echo(f"Updated TypeScript package.json version to {version}")


 def get_current_branch() -> str:
@@ -90,7 +120,7 @@ def get_current_branch() -> str:
    return result.stdout.strip()


-def create_if_not_exists(version: str) -> None:
+def create_if_not_exists(version: str) -> str:
    """Create a git tag and push it."""
    current_branch = get_current_branch()
    if current_branch != "main":
@@ -99,27 +129,26 @@ def create_if_not_exists(version: str) -> None:
        )
        sys.exit(1)

-    tag_name = f"v{version}"
-    if not tag_exists(version):
+    tag_name = f"v{version}" if version[0].isdigit() else version
+    if not tag_exists(tag_name):
        # Create tag
        subprocess.run(["git", "tag", tag_name], check=True)
        click.echo(f"Created tag {tag_name}")
    else:
        click.echo(f"Tag {tag_name} already exists")
+    return tag_name


-def tag_exists(version: str) -> bool:
+def tag_exists(tag_name: str) -> bool:
    """Check if a git tag exists."""
-    tag_name = f"v{version}"
    result = subprocess.run(
        ["git", "tag", "-l", tag_name], capture_output=True, text=True, check=True
    )
    return tag_name in result.stdout.strip()


-def push_tag(version: str) -> None:
+def push_tag(tag_name: str) -> None:
    """Push a git tag."""
-    tag_name = f"v{version}"
    subprocess.run(["git", "push", "origin", tag_name], check=True)
    click.echo(f"Pushed tag {tag_name}")

@@ -133,12 +162,18 @@ def cli() -> None:
@cli.command()
 def get() -> None:
    """Get current versions and show validation warnings."""
-    main_version, llama_parse_version, dependency_version = get_current_versions()
+    (
+        main_version,
+        llama_parse_version,
+        dependency_version,
+        ts_version,
+    ) = get_current_versions()

    click.echo("Current versions:")
    click.echo(f"  llama-cloud-services: {main_version}")
    click.echo(f"  llama-parse: {llama_parse_version}")
    click.echo(f"  dependency reference: {dependency_version}")
+    click.echo(f"  typescript package: {ts_version}")

    warnings = validate_versions(main_version, llama_parse_version, dependency_version)
    if warnings:
@@ -151,9 +186,15 @@ def get() -> None:

@cli.command()
@click.argument("version")
-def set(version: str) -> None:
-    """Set version across all pyproject.toml files."""
-    set_version(version)
+@click.option("--js", is_flag=True, help="Update TypeScript package.json only")
+def set(version: str, js: bool) -> None:
+    """Set version for Python, TypeScript, or both (default: Python only)."""
+
+    if js:
+        set_ts_version(version)
+        return
+    else:
+        set_version(version)


@cli.command()
@@ -165,15 +206,20 @@ def set(version: str) -> None:
    is_flag=True,
    help="Push the tag to the remote repository",
 )
-def tag(version: str | None = None, push: bool = False) -> None:
+@click.option(
+    "--js",
+    is_flag=True,
+    help="tag TypeScript package.json only",
+)
+def tag(version: str | None = None, push: bool = False, js: bool = False) -> None:
    """Create and push a git tag for the current version."""
    if not version:
-        main_version, _, _ = get_current_versions()
-        version = main_version
+        main_version, _, _, js_version = get_current_versions()
+        version = f"llama-cloud-services@{js_version}" if js else main_version

-    create_if_not_exists(version)
+    tag_name = create_if_not_exists(version)
    if push:
-        push_tag(version)
+        push_tag(tag_name)


 if __name__ == "__main__":
@@ -1,6 +1,6 @@
 {
  "name": "llama-cloud-services",
-  "version": "0.3.4",
+  "version": "0.3.5",
  "type": "module",
  "license": "MIT",
  "scripts": {
@@ -9,6 +9,7 @@
    "dev": "bunchee --watch",
    "lint": "eslint src/ --ignore-pattern client/*.ts --no-warn-ignored",
    "format": "prettier --write ./src/",
+    "format:check": "prettier --check ./src/",
    "test": "vitest run --testTimeout=60000",
    "test:watch": "vitest --watch",
    "test:ui": "vitest --ui",
@@ -16350,7 +16350,7 @@ export const PromptConfSchema = {
      default: `
 Provide a brief explanation for how you arrived at the extracted value based on the source text provided.
 - For inferred values, explain the reasoning behind the extraction briefly.
- For simple verbatim extraction, output 'VERBATIM EXTRACTION'.
+- For simple verbatim extraction, output 'VERBATIM EXTRACTION'. 
 - When supporting data is not present in the source text, output 'INSUFFICIENT DATA' and emit blank or null values for the value__ field.
 `,
    },
@@ -17689,7 +17689,7 @@ export const StructParseConfSchema = {
        reasoning_prompt: `
 Provide a brief explanation for how you arrived at the extracted value based on the source text provided.
 - For inferred values, explain the reasoning behind the extraction briefly.
- For simple verbatim extraction, output 'VERBATIM EXTRACTION'.
+- For simple verbatim extraction, output 'VERBATIM EXTRACTION'. 
 - When supporting data is not present in the source text, output 'INSUFFICIENT DATA' and emit blank or null values for the value__ field.
 `,
        cite_sources_prompt: {
@@ -3219,7 +3219,7 @@ export const zPromptConf = z.object({
  reasoning_prompt: z.string().optional().default(`
 Provide a brief explanation for how you arrived at the extracted value based on the source text provided.
 - For inferred values, explain the reasoning behind the extraction briefly.
- For simple verbatim extraction, output 'VERBATIM EXTRACTION'.
+- For simple verbatim extraction, output 'VERBATIM EXTRACTION'. 
 - When supporting data is not present in the source text, output 'INSUFFICIENT DATA' and emit blank or null values for the value__ field.
 `),
  cite_sources_prompt: z
@@ -147,6 +147,10 @@ export class LlamaParseReader extends FileReader {
  output_s3_region?: string | undefined;
  preserve_layout_alignment_across_pages?: boolean | undefined;
  spreadsheet_extract_sub_tables?: boolean | undefined;
+  specialized_chart_parsing_agentic?: boolean | undefined;
+  specialized_chart_parsing_efficient?: boolean | undefined;
+  specialized_chart_parsing_plus?: boolean | undefined;
+  precise_bounding_box?: boolean | undefined;
  formatting_instruction?: string | undefined;
  parse_mode?: ParsingMode | undefined;
  system_prompt?: string | undefined;
@@ -194,7 +198,7 @@ export class LlamaParseReader extends FileReader {
      ? this.language
      : [this.language];
    this.stdout =
-      params.stdout ?? typeof process !== "undefined"
+      (params.stdout ?? typeof process !== "undefined")
        ? process!.stdout
        : undefined;
    const apiKey = params.apiKey ?? getEnv("LLAMA_CLOUD_API_KEY");
@@ -331,6 +335,11 @@ export class LlamaParseReader extends FileReader {
      preserve_layout_alignment_across_pages:
        this.preserve_layout_alignment_across_pages,
      spreadsheet_extract_sub_tables: this.spreadsheet_extract_sub_tables,
+      specialized_chart_parsing_agentic: this.specialized_chart_parsing_agentic,
+      specialized_chart_parsing_efficient:
+        this.specialized_chart_parsing_efficient,
+      specialized_chart_parsing_plus: this.specialized_chart_parsing_plus,
+      precise_bounding_box: this.precise_bounding_box,
      formatting_instruction: this.formatting_instruction,
      parse_mode: this.parse_mode,
      system_prompt: this.system_prompt,
@@ -87,6 +87,10 @@ export const parseFormSchema = z.object({
  preserve_layout_alignment_across_pages: z.boolean().optional(),
  skip_diagonal_text: z.boolean().optional(),
  spreadsheet_extract_sub_tables: z.boolean().optional(),
+  specialized_chart_parsing_agentic: z.boolean().optional(),
+  specialized_chart_parsing_efficient: z.boolean().optional(),
+  specialized_chart_parsing_plus: z.boolean().optional(),
+  precise_bounding_box: z.boolean().optional(),
  structured_output: z.boolean().optional(),
  structured_output_json_schema: z.string().optional(),
  structured_output_json_schema_name: z.string().optional(),
Author	SHA1	Message	Date
George He	d2380778e3	Precommit lint	2025-09-12 09:58:37 -07:00
George He	2284eefc95	Fix comments	2025-09-12 09:55:41 -07:00
George He	93ede11f0d	Parse error handling	2025-09-12 09:51:20 -07:00
Adrian Lyjak	d9aed80ded	fix: v prefix goes deeper. Fix more (#899 )	2025-09-08 17:45:06 -04:00
Pierre-Loic Doulcet	c07d2d70a8	update parse package (#911 )	2025-09-08 09:46:32 -06:00
Neeraj Pradhan	ed6937a5a9	Fix uv sync; remove poetry lock (#906 )	2025-09-05 17:13:31 -07:00
Neeraj Pradhan	34c15932a3	Bump version to 0.6.64 (#904 )	2025-09-05 17:05:21 -07:00
Neeraj Pradhan	b18ea96d11	Remove report generation related code from llama_cloud_services (#905 )	2025-09-05 16:41:28 -07:00
Clelia (Astra) Bertelli	196ab827f5	fix: make ts release beautiful again (#902 )	2025-09-05 10:41:39 -06:00
Peter Rowlands (변기호)	ba4cb4d5e9	parse: expose page.slideSpeakerNotes (#889 )	2025-09-05 15:48:44 +09:00
Adrian Lyjak	58d883b825	fix: "v" prefix being added to js versions (#898 )	2025-09-04 15:39:27 -04:00
Adrian Lyjak	5fc5ebfc6c	client unification (#895 ) read from the shared client	2025-09-04 14:12:28 -04:00
Adrian Lyjak	fe3e20fd53	Update version script, and unify the linting so that prettier is more consistent (#897 ) Add version script, and unify the linting so that prettier is more consistent	2025-09-04 14:09:27 -04:00