batchor 0.0.3__tar.gz → 0.0.5__tar.gz

{batchor-0.0.3 → batchor-0.0.5}/.agents/plugins/marketplace.json

@@ -15,6 +15,18 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Coding"
+    },
+    {
+      "name": "batchor",
+      "source": {
+        "source": "local",
+        "path": "./plugins/batchor"
+      },
+      "policy": {
+        "installation": "AVAILABLE",
+        "authentication": "ON_INSTALL"
+      },
+      "category": "Coding"
     }
   ]
 }

{batchor-0.0.3 → batchor-0.0.5}/.agents/skills/batchor-dev/SKILL.md

@@ -14,13 +14,14 @@ Use this skill for normal contributor work in this repository.
 3. Load only the design docs that match the task:
    - `docs/design_docs/ARCHITECTURE.md` for package layout and runtime boundaries
    - `docs/design_docs/OPENAI_BATCHING.md` for provider-specific batching behavior
+   - `docs/design_docs/ANTHROPIC_BATCHING.md` for Anthropic Message Batches behavior
    - `docs/design_docs/STORAGE_AND_RUNS.md` for durable state, run lifecycle, and retention
    - `docs/smoke-test.md` for the full validation matrix
 
 ## Repo map
 
 - `src/batchor/runtime/`: orchestration, run handles, validation, retry, token budgeting
-- `src/batchor/providers/`: provider interfaces and OpenAI Batch implementation
+- `src/batchor/providers/`: provider interfaces and OpenAI, Anthropic, and Gemini implementations
 - `src/batchor/storage/`: SQLite, Postgres, and in-memory durability backends
 - `src/batchor/sources/`: file-backed checkpointable item sources
 - `src/batchor/artifacts/`: durable request/output artifact handling

{batchor-0.0.3 → batchor-0.0.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: batchor
-Version: 0.0.3
-Summary: Structured-first OpenAI Batch runner with typed Pydantic results.
+Version: 0.0.5
+Summary: Structured-first provider Batch runner with typed Pydantic results.
 Project-URL: Documentation, https://github.com/AnsonDev42/batchor#readme
 Project-URL: Repository, https://github.com/AnsonDev42/batchor
 Project-URL: Issues, https://github.com/AnsonDev42/batchor/issues
@@ -79,7 +79,7 @@ License: # PolyForm Noncommercial License 1.0.0
         
         **Use** means anything you do with the software requiring one of your licenses.
 License-File: LICENSE
-Keywords: batch,cli,openai,pydantic,sqlite
+Keywords: anthropic,batch,cli,gemini,openai,pydantic,sqlite
 Classifier: Development Status :: 3 - Alpha
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -99,13 +99,18 @@ Requires-Dist: python-dotenv<2,>=1.0.1
 Requires-Dist: sqlalchemy<3,>=2.0.43
 Requires-Dist: tiktoken>=0.12.0
 Requires-Dist: typer<1,>=0.16.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic<1,>=0.71.0; extra == 'anthropic'
+Provides-Extra: gemini
+Requires-Dist: google-cloud-storage<4,>=3.4.0; extra == 'gemini'
+Requires-Dist: google-genai<2,>=1.55.0; extra == 'gemini'
 Description-Content-Type: text/markdown
 
 # batchor
 
 `batchor` grew out of a recurring problem in academic research: running large datasets through LLMs in batch — reliably, reproducibly, and without reinventing the same glue code across every project. The patterns that kept emerging (durable state, typed results, safe resume after failure) were extracted into this library so they do not have to be rebuilt each time.
 
-`batchor` is a durable OpenAI Batch runner for Python teams that want:
+`batchor` is a durable provider Batch runner for Python teams that want:
 
 - typed Pydantic results
 - resumable durable runs
@@ -115,7 +120,7 @@ Description-Content-Type: text/markdown
 - library-first run controls
 - a small operator CLI for CSV and JSONL jobs
 
-It is intentionally narrow today: OpenAI-first, SQLite-first, and library-first.
+It is intentionally narrow today: OpenAI is the CLI default, Anthropic and Gemini are opt-in through provider extras, SQLite is the CLI durability backend, and the Python API exposes the broadest configuration surface.
 
 ## What problem it solves
 
@@ -140,6 +145,8 @@ Most OpenAI Batch examples stop at "upload a JSONL file and poll until it finish
 Built-in implementations:
 
 - `OpenAIProviderConfig` + `OpenAIBatchProvider`
+- `AnthropicProviderConfig` + `AnthropicBatchProvider` for Claude Message Batches
+- `GeminiProviderConfig` + `GeminiBatchProvider` for text-only Gemini Batch jobs
 - `SQLiteStorage`
 - `PostgresStorage` as an opt-in durable control-plane backend
 - `MemoryStateStore`
@@ -155,6 +162,8 @@ Important constraints:
 - the CLI supports file-backed inputs only
 - users still own selecting and ordering input files or partitions
 - the built-in CLI uses SQLite durability only
+- the CLI supports OpenAI, Anthropic, Gemini Developer API, and Vertex AI text jobs
+- Gemini support is text-only for now and does not build multimodal requests
 - structured-output rehydration requires an importable module-level Pydantic model
 - raw output artifacts are retained by default and must be exported before raw pruning
 - pause/resume/cancel and incremental terminal-result APIs are library-first today
@@ -179,6 +188,14 @@ Durability is split on purpose:
 
 That split is what allows retries and fresh-process resume without keeping every request inline in the control-plane store.
 On resume, existing active provider batches are polled before `batchor` materializes or submits new local work, so completed batches and retry backoff are reconciled first. Deterministic sources also use stored checkpoint completion metadata to avoid opening a fully materialized Parquet or composite source just to discover there are no rows left.
+Incomplete checkpointed ingestion keeps the run non-terminal. In the process that
+started the job, `Run.resume()` can continue from the attached source. After a
+fresh-process rehydration, call `start(job, run_id=...)`; `refresh()` otherwise
+raises `RunIngestionSourceRequiredError` instead of silently completing only the
+already-materialized rows.
+Cancelling an incompletely ingested checkpointed source abandons its
+unmaterialized tail and finalizes the checkpoint after active batches drain, so
+the cancelled run can still reach a terminal lifecycle state.
 
 ## Architecture
 
@@ -189,10 +206,13 @@ graph LR
     subgraph runtime["runtime/"]
         BatchRunner
         Run["Run handle"]
+        Executor["RunExecutor"]
     end
 
     subgraph providers["providers/"]
         OpenAI["OpenAIBatchProvider"]
+        Anthropic["AnthropicBatchProvider"]
+        Gemini["GeminiBatchProvider"]
     end
 
     subgraph sources["sources/"]
@@ -211,7 +231,10 @@ graph LR
 
     User -->|"start() / run_and_wait()"| BatchRunner
     BatchRunner --> Run
+    BatchRunner --> Executor
     BatchRunner --> OpenAI
+    BatchRunner --> Anthropic
+    BatchRunner --> Gemini
     BatchRunner --> SQLite
     BatchRunner --> LocalFS
     Files -->|"BatchItem stream"| BatchRunner
@@ -247,16 +270,37 @@ Operational semantics for resume, run control, and artifact retention live in
 pip install batchor
 ```
 
-## Repo Agent Setup
+For Gemini Batch support, install the optional extra:
 
-This repo now includes local AI-agent scaffolding so a contributor agent can pick up repo conventions without extra global setup:
+```bash
+pip install "batchor[gemini]"
+```
+
+For Anthropic Message Batches support:
+
+```bash
+pip install "batchor[anthropic]"
+```
+
+## Agent setup
+
+Batchor keeps contributor tooling separate from the tools intended for researchers and downstream projects:
+
+- `plugins/batchor/` is the user-facing Codex plugin. Its `$use-batchor` skill and MCP helpers turn datasets and prompts into safe CLI or Python workflows without assuming a Batchor source checkout.
+- `.agents/skills/batchor-dev/` and `plugins/batchor-agent-tools/` are contributor-only. They teach agents how to change this repository, find design docs, and run its validation suite.
+- `.agents/plugins/marketplace.json` registers both plugins for local development.
+- `.vscode/mcp.json` configures the contributor MCP for this workspace.
 
-- repo-local skill: `.agents/skills/batchor-dev/`
-- repo-local plugin marketplace: `.agents/plugins/marketplace.json`
-- repo-local MCP plugin: `plugins/batchor-agent-tools/`
-- VS Code workspace MCP config: `.vscode/mcp.json`
+The PyPI package remains the runtime dependency: `pip install batchor` installs the library and CLI. Agent skills and MCP configuration are distributed as the separate `batchor` plugin so Python environments do not receive Codex-specific files implicitly.
 
-The skill captures repo-specific workflow and validation guidance. The MCP plugin exposes a small repo-aware guide for project overview, docs entry points, and validation commands.
+To try the user plugin from a local checkout:
+
+```bash
+codex plugin marketplace add /path/to/batchor
+codex plugin add batchor@batchor-local
+```
+
+Start a new Codex task after installation, then ask: `Use $use-batchor to turn my CSV and research prompt into a resumable batch job.`
 
 Supported Python versions:
 
@@ -268,8 +312,9 @@ Supported Python versions:
 
 For Python API usage, auth resolution is:
 
-1. explicit `OpenAIProviderConfig(api_key=...)`
-2. ambient `OPENAI_API_KEY`
+1. explicit provider config credentials such as `OpenAIProviderConfig(api_key=...)`, `AnthropicProviderConfig(api_key=...)`, or `GeminiProviderConfig(api_key=...)`
+2. ambient provider environment variables: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `GEMINI_API_KEY`
+3. Vertex AI Application Default Credentials when `GeminiProviderConfig(vertexai=True, ...)` or `GOOGLE_GENAI_USE_VERTEXAI=true` is used
 
 The Python library does not auto-load `.env`.
 
@@ -298,6 +343,66 @@ run = runner.run_and_wait(
 print(run.results()[0].output_text)
 ```
 
+### Anthropic text job
+
+```python
+from batchor import AnthropicProviderConfig, BatchItem, BatchJob, BatchRunner, PromptParts
+
+
+runner = BatchRunner(storage="memory")
+run = runner.run_and_wait(
+    BatchJob(
+        items=[BatchItem(item_id="row1", payload="Summarize this text")],
+        build_prompt=lambda item: PromptParts(prompt=item.payload),
+        provider_config=AnthropicProviderConfig(
+            model="claude-sonnet-4-5",
+            max_tokens=1024,
+        ),
+    )
+)
+
+print(run.results()[0].output_text)
+```
+
+Anthropic support maps Batchor attempt identifiers deterministically to Claude-safe `custom_id` values and supports system prompts, `message_params`, and structured outputs through `output_config.format`.
+
+### Gemini text job
+
+```python
+from batchor import BatchItem, BatchJob, BatchRunner, GeminiProviderConfig, PromptParts
+
+
+runner = BatchRunner(storage="memory")
+run = runner.run_and_wait(
+    BatchJob(
+        items=[BatchItem(item_id="row1", payload="Summarize this text")],
+        build_prompt=lambda item: PromptParts(prompt=item.payload),
+        provider_config=GeminiProviderConfig(
+            model="gemini-2.5-flash",
+            api_key="YOUR_GEMINI_API_KEY",
+        ),
+    )
+)
+
+print(run.results()[0].output_text)
+```
+
+Gemini support currently builds text-only `GenerateContent` batch requests. It uses Gemini JSONL `key` values internally while keeping `batchor`'s durable item and attempt tracking unchanged.
+
+For Vertex AI, provide a Cloud Storage staging prefix and use Application Default Credentials:
+
+```python
+provider_config = GeminiProviderConfig(
+    model="gemini-2.5-flash",
+    vertexai=True,
+    project="my-project",
+    location="europe-west8",
+    gcs_uri="gs://my-bucket/batchor",
+)
+```
+
+Vertex AI stages JSONL input and output in that prefix. The Gemini Developer API uses inline requests for batches below 20 MB and the Files API for larger batches; `input_mode=` can override that automatic choice. Vertex request/output correlation uses a generated request label because Vertex output does not include the Developer API JSONL `key`.
+
 ### Structured output
 
 ```python
@@ -351,6 +456,8 @@ Structured-output models are validated up front against the OpenAI strict-schema
 
 If you need a field to be optional in Python, model it as nullable in the schema shape OpenAI accepts rather than relying on omitted required fields.
 
+The same `structured_output=` API is available with `GeminiProviderConfig`; batchor sends the schema through Gemini `generation_config.response_json_schema` and validates the returned JSON text with the same Pydantic model.
+
 ### Rehydrate a durable run
 
 ```python
@@ -498,6 +605,31 @@ The CLI is intentionally narrower than the Python API:
 - CSV and JSONL only
 - SQLite-backed durable runs only
 
+OpenAI remains the default provider. For Gemini, install `batchor[gemini]` and select the backend explicitly or let `auto` follow `GOOGLE_GENAI_USE_VERTEXAI`:
+
+```bash
+batchor start \
+  --input input/items.jsonl \
+  --id-field id \
+  --prompt-field text \
+  --provider gemini \
+  --model gemini-2.5-flash \
+  --gemini-backend developer
+```
+
+Vertex AI additionally needs a writable staging prefix:
+
+```bash
+batchor start \
+  --input input/items.jsonl \
+  --id-field id \
+  --prompt-field text \
+  --provider gemini \
+  --model gemini-2.5-flash \
+  --gemini-backend vertex \
+  --gcs-uri gs://my-bucket/batchor
+```
+
 Start a run from JSONL:
 
 ```bash

{batchor-0.0.3 → batchor-0.0.5}/README.md

@@ -2,7 +2,7 @@
 
 `batchor` grew out of a recurring problem in academic research: running large datasets through LLMs in batch — reliably, reproducibly, and without reinventing the same glue code across every project. The patterns that kept emerging (durable state, typed results, safe resume after failure) were extracted into this library so they do not have to be rebuilt each time.
 
-`batchor` is a durable OpenAI Batch runner for Python teams that want:
+`batchor` is a durable provider Batch runner for Python teams that want:
 
 - typed Pydantic results
 - resumable durable runs
@@ -12,7 +12,7 @@
 - library-first run controls
 - a small operator CLI for CSV and JSONL jobs
 
-It is intentionally narrow today: OpenAI-first, SQLite-first, and library-first.
+It is intentionally narrow today: OpenAI is the CLI default, Anthropic and Gemini are opt-in through provider extras, SQLite is the CLI durability backend, and the Python API exposes the broadest configuration surface.
 
 ## What problem it solves
 
@@ -37,6 +37,8 @@ Most OpenAI Batch examples stop at "upload a JSONL file and poll until it finish
 Built-in implementations:
 
 - `OpenAIProviderConfig` + `OpenAIBatchProvider`
+- `AnthropicProviderConfig` + `AnthropicBatchProvider` for Claude Message Batches
+- `GeminiProviderConfig` + `GeminiBatchProvider` for text-only Gemini Batch jobs
 - `SQLiteStorage`
 - `PostgresStorage` as an opt-in durable control-plane backend
 - `MemoryStateStore`
@@ -52,6 +54,8 @@ Important constraints:
 - the CLI supports file-backed inputs only
 - users still own selecting and ordering input files or partitions
 - the built-in CLI uses SQLite durability only
+- the CLI supports OpenAI, Anthropic, Gemini Developer API, and Vertex AI text jobs
+- Gemini support is text-only for now and does not build multimodal requests
 - structured-output rehydration requires an importable module-level Pydantic model
 - raw output artifacts are retained by default and must be exported before raw pruning
 - pause/resume/cancel and incremental terminal-result APIs are library-first today
@@ -76,6 +80,14 @@ Durability is split on purpose:
 
 That split is what allows retries and fresh-process resume without keeping every request inline in the control-plane store.
 On resume, existing active provider batches are polled before `batchor` materializes or submits new local work, so completed batches and retry backoff are reconciled first. Deterministic sources also use stored checkpoint completion metadata to avoid opening a fully materialized Parquet or composite source just to discover there are no rows left.
+Incomplete checkpointed ingestion keeps the run non-terminal. In the process that
+started the job, `Run.resume()` can continue from the attached source. After a
+fresh-process rehydration, call `start(job, run_id=...)`; `refresh()` otherwise
+raises `RunIngestionSourceRequiredError` instead of silently completing only the
+already-materialized rows.
+Cancelling an incompletely ingested checkpointed source abandons its
+unmaterialized tail and finalizes the checkpoint after active batches drain, so
+the cancelled run can still reach a terminal lifecycle state.
 
 ## Architecture
 
@@ -86,10 +98,13 @@ graph LR
     subgraph runtime["runtime/"]
         BatchRunner
         Run["Run handle"]
+        Executor["RunExecutor"]
     end
 
     subgraph providers["providers/"]
         OpenAI["OpenAIBatchProvider"]
+        Anthropic["AnthropicBatchProvider"]
+        Gemini["GeminiBatchProvider"]
     end
 
     subgraph sources["sources/"]
@@ -108,7 +123,10 @@ graph LR
 
     User -->|"start() / run_and_wait()"| BatchRunner
     BatchRunner --> Run
+    BatchRunner --> Executor
     BatchRunner --> OpenAI
+    BatchRunner --> Anthropic
+    BatchRunner --> Gemini
     BatchRunner --> SQLite
     BatchRunner --> LocalFS
     Files -->|"BatchItem stream"| BatchRunner
@@ -144,16 +162,37 @@ Operational semantics for resume, run control, and artifact retention live in
 pip install batchor
 ```
 
-## Repo Agent Setup
+For Gemini Batch support, install the optional extra:
 
-This repo now includes local AI-agent scaffolding so a contributor agent can pick up repo conventions without extra global setup:
+```bash
+pip install "batchor[gemini]"
+```
+
+For Anthropic Message Batches support:
+
+```bash
+pip install "batchor[anthropic]"
+```
+
+## Agent setup
+
+Batchor keeps contributor tooling separate from the tools intended for researchers and downstream projects:
+
+- `plugins/batchor/` is the user-facing Codex plugin. Its `$use-batchor` skill and MCP helpers turn datasets and prompts into safe CLI or Python workflows without assuming a Batchor source checkout.
+- `.agents/skills/batchor-dev/` and `plugins/batchor-agent-tools/` are contributor-only. They teach agents how to change this repository, find design docs, and run its validation suite.
+- `.agents/plugins/marketplace.json` registers both plugins for local development.
+- `.vscode/mcp.json` configures the contributor MCP for this workspace.
 
-- repo-local skill: `.agents/skills/batchor-dev/`
-- repo-local plugin marketplace: `.agents/plugins/marketplace.json`
-- repo-local MCP plugin: `plugins/batchor-agent-tools/`
-- VS Code workspace MCP config: `.vscode/mcp.json`
+The PyPI package remains the runtime dependency: `pip install batchor` installs the library and CLI. Agent skills and MCP configuration are distributed as the separate `batchor` plugin so Python environments do not receive Codex-specific files implicitly.
 
-The skill captures repo-specific workflow and validation guidance. The MCP plugin exposes a small repo-aware guide for project overview, docs entry points, and validation commands.
+To try the user plugin from a local checkout:
+
+```bash
+codex plugin marketplace add /path/to/batchor
+codex plugin add batchor@batchor-local
+```
+
+Start a new Codex task after installation, then ask: `Use $use-batchor to turn my CSV and research prompt into a resumable batch job.`
 
 Supported Python versions:
 
@@ -165,8 +204,9 @@ Supported Python versions:
 
 For Python API usage, auth resolution is:
 
-1. explicit `OpenAIProviderConfig(api_key=...)`
-2. ambient `OPENAI_API_KEY`
+1. explicit provider config credentials such as `OpenAIProviderConfig(api_key=...)`, `AnthropicProviderConfig(api_key=...)`, or `GeminiProviderConfig(api_key=...)`
+2. ambient provider environment variables: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `GEMINI_API_KEY`
+3. Vertex AI Application Default Credentials when `GeminiProviderConfig(vertexai=True, ...)` or `GOOGLE_GENAI_USE_VERTEXAI=true` is used
 
 The Python library does not auto-load `.env`.
 
@@ -195,6 +235,66 @@ run = runner.run_and_wait(
 print(run.results()[0].output_text)
 ```
 
+### Anthropic text job
+
+```python
+from batchor import AnthropicProviderConfig, BatchItem, BatchJob, BatchRunner, PromptParts
+
+
+runner = BatchRunner(storage="memory")
+run = runner.run_and_wait(
+    BatchJob(
+        items=[BatchItem(item_id="row1", payload="Summarize this text")],
+        build_prompt=lambda item: PromptParts(prompt=item.payload),
+        provider_config=AnthropicProviderConfig(
+            model="claude-sonnet-4-5",
+            max_tokens=1024,
+        ),
+    )
+)
+
+print(run.results()[0].output_text)
+```
+
+Anthropic support maps Batchor attempt identifiers deterministically to Claude-safe `custom_id` values and supports system prompts, `message_params`, and structured outputs through `output_config.format`.
+
+### Gemini text job
+
+```python
+from batchor import BatchItem, BatchJob, BatchRunner, GeminiProviderConfig, PromptParts
+
+
+runner = BatchRunner(storage="memory")
+run = runner.run_and_wait(
+    BatchJob(
+        items=[BatchItem(item_id="row1", payload="Summarize this text")],
+        build_prompt=lambda item: PromptParts(prompt=item.payload),
+        provider_config=GeminiProviderConfig(
+            model="gemini-2.5-flash",
+            api_key="YOUR_GEMINI_API_KEY",
+        ),
+    )
+)
+
+print(run.results()[0].output_text)
+```
+
+Gemini support currently builds text-only `GenerateContent` batch requests. It uses Gemini JSONL `key` values internally while keeping `batchor`'s durable item and attempt tracking unchanged.
+
+For Vertex AI, provide a Cloud Storage staging prefix and use Application Default Credentials:
+
+```python
+provider_config = GeminiProviderConfig(
+    model="gemini-2.5-flash",
+    vertexai=True,
+    project="my-project",
+    location="europe-west8",
+    gcs_uri="gs://my-bucket/batchor",
+)
+```
+
+Vertex AI stages JSONL input and output in that prefix. The Gemini Developer API uses inline requests for batches below 20 MB and the Files API for larger batches; `input_mode=` can override that automatic choice. Vertex request/output correlation uses a generated request label because Vertex output does not include the Developer API JSONL `key`.
+
 ### Structured output
 
 ```python
@@ -248,6 +348,8 @@ Structured-output models are validated up front against the OpenAI strict-schema
 
 If you need a field to be optional in Python, model it as nullable in the schema shape OpenAI accepts rather than relying on omitted required fields.
 
+The same `structured_output=` API is available with `GeminiProviderConfig`; batchor sends the schema through Gemini `generation_config.response_json_schema` and validates the returned JSON text with the same Pydantic model.
+
 ### Rehydrate a durable run
 
 ```python
@@ -395,6 +497,31 @@ The CLI is intentionally narrower than the Python API:
 - CSV and JSONL only
 - SQLite-backed durable runs only
 
+OpenAI remains the default provider. For Gemini, install `batchor[gemini]` and select the backend explicitly or let `auto` follow `GOOGLE_GENAI_USE_VERTEXAI`:
+
+```bash
+batchor start \
+  --input input/items.jsonl \
+  --id-field id \
+  --prompt-field text \
+  --provider gemini \
+  --model gemini-2.5-flash \
+  --gemini-backend developer
+```
+
+Vertex AI additionally needs a writable staging prefix:
+
+```bash
+batchor start \
+  --input input/items.jsonl \
+  --id-field id \
+  --prompt-field text \
+  --provider gemini \
+  --model gemini-2.5-flash \
+  --gemini-backend vertex \
+  --gcs-uri gs://my-bucket/batchor
+```
+
 Start a run from JSONL:
 
 ```bash

batchor-0.0.5/docs/design_docs/ANTHROPIC_BATCHING.md

@@ -0,0 +1,33 @@
+# Anthropic Batching
+
+The built-in Anthropic provider targets the Claude Message Batches API.
+
+## Request mapping
+
+Each Batchor item attempt becomes one Anthropic batch request:
+
+- Batchor's durable correlation identifier is deterministically hashed into Anthropic's 64-character-safe `custom_id` alphabet
+- `PromptParts.prompt` becomes one user message
+- `PromptParts.system_prompt` becomes the top-level `system` parameter
+- `model` and `max_tokens` come from `AnthropicProviderConfig`
+- `message_params` supplies optional Messages API parameters
+- structured output schemas use `output_config.format`
+
+Batchor rejects provider-owned fields in `message_params` so replayed requests cannot silently change model, token limit, messages, system prompt, or streaming behavior.
+
+## Submission and lifecycle
+
+Anthropic accepts request objects directly rather than an uploaded JSONL file. The provider therefore stages Batchor's durable request artifact in memory only for the upload/create boundary, then calls `messages.batches.create(requests=...)`.
+
+Anthropic `in_progress` maps to Batchor's active status and `ended` maps to `completed`. Once ended, the provider streams `messages.batches.results(...)` into Batchor's raw output artifact. Result order is not assumed; correlation always uses `custom_id`.
+
+The four Anthropic result types map as follows:
+
+- `succeeded`: Batchor success
+- `errored`, `canceled`, and `expired`: Batchor item error, subject to the configured retry policy
+
+## Limits and retention
+
+Anthropic currently limits a Message Batch to 100,000 requests or 256 MB. Batchor's default chunk limits are lower than both limits. Claude batch results remain available from Anthropic for 29 days; Batchor downloads and retains them according to its artifact policy, so durable runs do not depend on that remote retention window after ingestion.
+
+Message Batches are not eligible for Anthropic Zero Data Retention. Users should account for Anthropic's batch retention policy when selecting workloads.