batchwork-ai 0.2.2__tar.gz → 0.2.3__tar.gz

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batchwork-ai
-Version: 0.2.2
+Version: 0.2.3
 Summary: Unified async batch API for AI providers
 Keywords: ai,anthropic,batch,gemini,llm,openai
 Author: Ajanraj
@@ -174,6 +174,10 @@ The base package does not import or require `upstash-redis`.
 - [Public API](https://batchwork.ajanraj.com/docs/api)
 - [FAQ](https://batchwork.ajanraj.com/docs/faq)
 
+## Built with Codex and GPT-5.6
+
+Batchwork was built entirely in the OpenAI Codex CLI with GPT-5.6 during [OpenAI Build Week](https://openai.devpost.com/) (July 2026) — the Python library, the `batchwork` CLI with its machine output contract and local job registry, the Agent Skill, the test suite, and the documentation site. Codex planned the design through a decision interview, implemented the seven provider adapters across three modalities, hardened security through repeated review loops, verified everything against live provider APIs, and drove the PyPI and documentation releases. The full collaboration story, plus a self-contained demo project for judges, lives in [`hackathon/`](hackathon/README.md).
+
 ## License
 
 [MIT](https://opensource.org/licenses/MIT) © [Ajanraj](https://github.com/ajanraj)

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/README.md

@@ -142,6 +142,10 @@ The base package does not import or require `upstash-redis`.
 - [Public API](https://batchwork.ajanraj.com/docs/api)
 - [FAQ](https://batchwork.ajanraj.com/docs/faq)
 
+## Built with Codex and GPT-5.6
+
+Batchwork was built entirely in the OpenAI Codex CLI with GPT-5.6 during [OpenAI Build Week](https://openai.devpost.com/) (July 2026) — the Python library, the `batchwork` CLI with its machine output contract and local job registry, the Agent Skill, the test suite, and the documentation site. Codex planned the design through a decision interview, implemented the seven provider adapters across three modalities, hardened security through repeated review loops, verified everything against live provider APIs, and drove the PyPI and documentation releases. The full collaboration story, plus a self-contained demo project for judges, lives in [`hackathon/`](hackathon/README.md).
+
 ## License
 
 [MIT](https://opensource.org/licenses/MIT) © [Ajanraj](https://github.com/ajanraj)

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "batchwork-ai"
-version = "0.2.2"
+version = "0.2.3"
 description = "Unified async batch API for AI providers"
 readme = "README.md"
 requires-python = ">=3.11"

batchwork_ai-0.2.3/src/batchwork/_base_url.py

@@ -0,0 +1,56 @@
+"""Provider base URL validation and normalization."""
+
+from __future__ import annotations
+
+from ipaddress import ip_address
+from urllib.parse import urlsplit, urlunsplit
+
+
+class BaseUrlError(ValueError):
+    """A provider base URL violates the outbound credential policy."""
+
+
+def _policy_error(label: str) -> BaseUrlError:
+    return BaseUrlError(
+        f"{label} must be absolute HTTPS (HTTP allowed for loopback), without "
+        "userinfo, query, or fragment."
+    )
+
+
+def normalize_base_url(value: str, label: str = "base URL") -> str:
+    """Validate a provider endpoint and remove trailing path slashes."""
+    raw_scheme, separator, remainder = value.partition("://")
+    authority = remainder
+    for delimiter in "/?#":
+        authority = authority.partition(delimiter)[0]
+    try:
+        parsed = urlsplit(value)
+        hostname = parsed.hostname
+    except ValueError as error:
+        raise _policy_error(label) from error
+    try:
+        _ = parsed.port
+    except ValueError as error:
+        raise BaseUrlError(f"{label} contains an invalid port.") from error
+
+    loopback = hostname == "localhost"
+    if hostname is not None:
+        try:
+            loopback = loopback or ip_address(hostname).is_loopback
+        except ValueError:
+            pass
+
+    if (
+        not separator
+        or raw_scheme.lower() != parsed.scheme
+        or not hostname
+        or any(character.isspace() for character in authority)
+        or parsed.username is not None
+        or parsed.password is not None
+        or "?" in value
+        or "#" in value
+        or (parsed.scheme != "https" and not (parsed.scheme == "http" and loopback))
+    ):
+        raise _policy_error(label)
+
+    return urlunsplit((parsed.scheme, parsed.netloc, parsed.path.rstrip("/"), "", ""))

batchwork_ai-0.2.3/src/batchwork/_read_retry.py

@@ -0,0 +1,89 @@
+"""Provider-neutral retry policy for safe read operations."""
+
+from __future__ import annotations
+
+import asyncio
+import random
+import ssl
+import time
+from collections.abc import Awaitable, Callable
+from typing import TypeVar
+
+import httpx
+
+from ._provider_failure import ProviderFailureError, ProviderFailureKind
+
+_READ_ATTEMPTS = 3
+_RETRYABLE_HTTP_STATUSES = frozenset({408, 429, 500, 502, 503, 504})
+_MAX_RETRY_DELAY_SECONDS = 60.0
+_ReadResult = TypeVar("_ReadResult")
+
+
+class _ReadRetryDeadlineExceeded(TimeoutError):
+    """The local read-retry deadline expired before another attempt."""
+
+
+def _cause_chain(error: BaseException) -> list[BaseException]:
+    causes: list[BaseException] = []
+    current: BaseException | None = error
+    while current is not None and current not in causes:
+        causes.append(current)
+        current = current.__cause__ or current.__context__
+    return causes
+
+
+def _retryable_read_failure(error: BaseException) -> bool:
+    if not isinstance(error, ProviderFailureError):
+        return False
+    failure = error.failure
+    if failure.kind is ProviderFailureKind.UNAVAILABLE:
+        return failure.status_code in _RETRYABLE_HTTP_STATUSES
+    if failure.kind is not ProviderFailureKind.TRANSPORT:
+        return False
+    causes = _cause_chain(error)
+    if any(isinstance(cause, ssl.SSLError) for cause in causes):
+        return False
+    return any(
+        isinstance(
+            cause,
+            (
+                httpx.ConnectError,
+                httpx.ConnectTimeout,
+                httpx.ReadError,
+                httpx.ReadTimeout,
+            ),
+        )
+        for cause in causes
+    )
+
+
+def _retry_delay(error: BaseException, retry_index: int) -> float:
+    if isinstance(error, ProviderFailureError):
+        retry_after = error.failure.retry_after_seconds
+        if retry_after is not None:
+            return min(float(retry_after), _MAX_RETRY_DELAY_SECONDS)
+    ceiling = min(0.25 * (2**retry_index), _MAX_RETRY_DELAY_SECONDS)
+    return random.uniform(ceiling / 2, ceiling)
+
+
+async def _retry_read(
+    read: Callable[[], Awaitable[_ReadResult]],
+    *,
+    deadline: float | None = None,
+) -> _ReadResult:
+    for attempt in range(_READ_ATTEMPTS):
+        try:
+            return await read()
+        except Exception as error:
+            if attempt + 1 == _READ_ATTEMPTS or not _retryable_read_failure(error):
+                raise
+            delay = _retry_delay(error, attempt)
+            if deadline is not None:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise _ReadRetryDeadlineExceeded from None
+                if delay >= remaining:
+                    await asyncio.sleep(remaining)
+                    raise _ReadRetryDeadlineExceeded from None
+            await asyncio.sleep(delay)
+    raise RuntimeError("batchwork: exhausted retry loop")

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/cli/_config.py

@@ -9,13 +9,13 @@ import sys
 import tomllib
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from ipaddress import ip_address
 from pathlib import Path
 from typing import Literal
-from urllib.parse import urlsplit, urlunsplit
 
 import click
 
+from batchwork._base_url import BaseUrlError
+from batchwork._base_url import normalize_base_url as normalize_core_base_url
 from batchwork.errors import BatchworkError
 from batchwork.types import BatchProvider, resolve_model
 
@@ -136,33 +136,10 @@ def registry_path(explicit: Path | None, environment: Mapping[str, str] = os.env
 def normalize_base_url(value: str | None, label: str = "base URL") -> str | None:
     if value is None:
         return None
-    parsed = urlsplit(value)
-    hostname = parsed.hostname
     try:
-        _ = parsed.port
-    except ValueError as error:
-        raise ConfigError(f"{label} contains an invalid port.", code="endpoint_invalid") from error
-    loopback = hostname == "localhost"
-    if hostname is not None:
-        try:
-            loopback = loopback or ip_address(hostname).is_loopback
-        except ValueError:
-            pass
-    if (
-        not hostname
-        or any(character.isspace() for character in parsed.netloc)
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.query
-        or parsed.fragment
-        or (parsed.scheme != "https" and not (parsed.scheme == "http" and loopback))
-    ):
-        raise ConfigError(
-            f"{label} must be absolute HTTPS (HTTP allowed for loopback), without "
-            "userinfo, query, or fragment.",
-            code="endpoint_invalid",
-        )
-    return urlunsplit((parsed.scheme, parsed.netloc, parsed.path.rstrip("/"), "", ""))
+        return normalize_core_base_url(value, label)
+    except BaseUrlError as error:
+        raise ConfigError(str(error), code="endpoint_invalid") from error
 
 
 def validate_environment_name(value: str, label: str) -> str:

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/cli/_contract.py

@@ -731,7 +731,8 @@ def reference_document() -> str:
     lines = [
         "---",
         "title: CLI machine schema",
-        "description: Generated schema-v1 envelopes and credential-free examples.",
+        'description: "Generated schema-v1 envelopes and credential-free examples for '
+        'machine-readable batchwork CLI stdout and stderr."',
         "---",
         "",
         "This page is generated from Batchwork's typed machine-output models. "

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/cli/_failures.py

@@ -118,7 +118,11 @@ def provider_failure(
     if failure is None:
         return None
     code, category, exit_code, message = _provider_mapping(failure)
-    retryable = category == "provider_availability" and not submission
+    retryable = (
+        category == "provider_availability"
+        and failure.kind is not ProviderFailureKind.PROTOCOL
+        and not submission
+    )
     submission_outcome = None
     recovery = None
     if submission:
@@ -138,6 +142,12 @@ def provider_failure(
             submission_outcome = "unknown"
             recovery = Recovery(action="inspect_provider_account")
         retryable = False
+    elif failure.kind is ProviderFailureKind.PROTOCOL:
+        message = (
+            "The provider returned an invalid lifecycle response. The remote job was not "
+            "modified and local state was not advanced. Check provider compatibility or "
+            "upgrade Batchwork before retrying."
+        )
     if (
         result_stream
         and category == "provider_availability"

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/cli/_lifecycle.py

@@ -4,19 +4,19 @@ from __future__ import annotations
 
 import asyncio
 import inspect
-import random
 import sqlite3
-import ssl
 import time
 from collections.abc import Awaitable, Callable, Sequence
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import TypeVar
 
-import httpx
-
-from batchwork._provider_failure import ProviderFailureError, ProviderFailureKind
+from batchwork._read_retry import (
+    _READ_ATTEMPTS,
+    _retry_delay,
+    _retry_read,
+    _retryable_read_failure,
+)
 from batchwork.client import Batchwork
 from batchwork.types import (
     BatchProvider,
@@ -69,11 +69,6 @@ from ._submit_text import (
     resolve_route_descriptor,
 )
 
-_READ_ATTEMPTS = 3
-_RETRYABLE_HTTP_STATUSES = frozenset({408, 429, 500, 502, 503, 504})
-_MAX_RETRY_DELAY_SECONDS = 60.0
-_ReadResult = TypeVar("_ReadResult")
-
 
 @dataclass(frozen=True, slots=True)
 class LifecycleOptions:
@@ -160,72 +155,6 @@ def active_signal_failure(*, interrupted: bool) -> LifecycleFailure | None:
     )
 
 
-def _cause_chain(error: BaseException) -> list[BaseException]:
-    causes: list[BaseException] = []
-    current: BaseException | None = error
-    while current is not None and current not in causes:
-        causes.append(current)
-        current = current.__cause__ or current.__context__
-    return causes
-
-
-def _retryable_read_failure(error: BaseException) -> bool:
-    if not isinstance(error, ProviderFailureError):
-        return False
-    failure = error.failure
-    if failure.kind is ProviderFailureKind.UNAVAILABLE:
-        return failure.status_code in _RETRYABLE_HTTP_STATUSES
-    if failure.kind is not ProviderFailureKind.TRANSPORT:
-        return False
-    causes = _cause_chain(error)
-    if any(isinstance(cause, ssl.SSLError) for cause in causes):
-        return False
-    return any(
-        isinstance(
-            cause,
-            (
-                httpx.ConnectError,
-                httpx.ConnectTimeout,
-                httpx.ReadError,
-                httpx.ReadTimeout,
-            ),
-        )
-        for cause in causes
-    )
-
-
-def _retry_delay(error: BaseException, retry_index: int) -> float:
-    if isinstance(error, ProviderFailureError):
-        retry_after = error.failure.retry_after_seconds
-        if retry_after is not None:
-            return min(float(retry_after), _MAX_RETRY_DELAY_SECONDS)
-    ceiling = min(0.25 * (2**retry_index), _MAX_RETRY_DELAY_SECONDS)
-    return random.uniform(ceiling / 2, ceiling)
-
-
-async def _retry_read(
-    read: Callable[[], Awaitable[_ReadResult]],
-    *,
-    deadline: float | None = None,
-) -> _ReadResult:
-    for attempt in range(_READ_ATTEMPTS):
-        try:
-            return await read()
-        except Exception as error:
-            if attempt + 1 == _READ_ATTEMPTS or not _retryable_read_failure(error):
-                raise
-            delay = _retry_delay(error, attempt)
-            if deadline is not None:
-                remaining = deadline - time.monotonic()
-                if remaining <= 0:
-                    raise TimeoutError from None
-                if delay >= remaining:
-                    await asyncio.sleep(remaining)
-                    raise TimeoutError from None
-            await asyncio.sleep(delay)
-    raise RuntimeError("batchwork: exhausted retry loop")
-
-
 def duration_seconds(duration: str | None) -> float | None:
     if duration is None:
         return None

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/cli/_submit_text.py

@@ -34,6 +34,7 @@ from batchwork.errors import (
 )
 from batchwork.job import BatchJob
 from batchwork.media import DefaultMediaResolver
+from batchwork.providers._capabilities import supports_batch_metadata
 from batchwork.types import (
     BatchDefaults,
     BatchEmbeddingDefaults,
@@ -331,11 +332,12 @@ def _resolve_route(
 
 
 def resolve_registered_route(provider: BatchProvider, route: RegistryRoute) -> ResolvedRoute:
+    base_url = normalize_base_url(route.base_url, "registered base URL")
     api_key = _environment_value(route.api_key_env, "API key")
     resolved_headers = dict(route.headers)
     for name, variable in route.header_env.items():
         resolved_headers[name] = _environment_value(variable, f'Header "{name}"')
-    return ResolvedRoute(api_key, route.base_url, resolved_headers, route)
+    return ResolvedRoute(api_key, base_url, resolved_headers, route)
 
 
 def _parse_json_object(document: str, label: str) -> dict[str, JsonValue]:
@@ -447,7 +449,6 @@ def _prepare_submission(
     *,
     modality: Modality,
     endpoint: str | None,
-    metadata_providers: frozenset[BatchProvider],
 ) -> _PreparedSubmission:
     loaded = load_config(root.config)
     profile_name, profile = select_profile(loaded, root.profile)
@@ -455,7 +456,7 @@ def _prepare_submission(
     if selected_model is None:
         raise _usage(f"--model is required for submit {modality}.")
     spec = _model_spec(selected_model, endpoint)
-    if options.batch_metadata and spec.provider not in metadata_providers:
+    if options.batch_metadata and not supports_batch_metadata(spec.provider):
         raise CliUsageError(
             f"Provider {spec.provider.value} does not support submission-level batch metadata.",
             code="unsupported_setting",
@@ -624,14 +625,6 @@ async def submit_text(
         options,
         modality="text",
         endpoint=options.endpoint,
-        metadata_providers=frozenset(
-            {
-                BatchProvider.OPENAI,
-                BatchProvider.GROQ,
-                BatchProvider.MISTRAL,
-                BatchProvider.TOGETHER,
-            }
-        ),
     )
     spec = prepared.spec
     route = prepared.route
@@ -732,7 +725,6 @@ async def submit_embeddings(
         options,
         modality="embeddings",
         endpoint=None,
-        metadata_providers=frozenset({BatchProvider.OPENAI, BatchProvider.MISTRAL}),
     )
     spec = prepared.spec
     route = prepared.route
@@ -821,7 +813,6 @@ async def submit_images(
         options,
         modality="images",
         endpoint=None,
-        metadata_providers=frozenset({BatchProvider.OPENAI}),
     )
     spec = prepared.spec
     route = prepared.route

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/client.py

@@ -19,6 +19,7 @@ from .body import (
 from .errors import BatchClosedError, BatchworkError, _LimitExceededError
 from .job import BatchJob
 from .media import DefaultMediaResolver, MediaResolver, MediaSource, ResolvedMedia
+from .providers._capabilities import validate_batch_metadata
 from .providers.adapter import BatchAdapter
 from .types import (
     AssistantMessage,
@@ -233,6 +234,7 @@ class Batchwork:
         validate_upload: Callable[[int], None] | None,
     ) -> BatchJob:
         spec = resolve_model(model)
+        validate_batch_metadata(spec.provider, metadata)
         self._validate_requests(requests)
         limits = limits or BatchLimits()
         validate_request_count(requests, limits)
@@ -255,6 +257,7 @@ class Batchwork:
             defaults,
             limits,
             kind=spec.kind,
+            strict=True,
         )
         prepared = await self._resolve_request_media(
             spec,
@@ -265,7 +268,13 @@ class Batchwork:
             budget=media_budget,
         )
         built = build_text_bodies(
-            spec.provider, spec.model_id, prepared, defaults, limits, kind=spec.kind
+            spec.provider,
+            spec.model_id,
+            prepared,
+            defaults,
+            limits,
+            kind=spec.kind,
+            strict=True,
         )
         if validate_upload is None:
             snapshot = await adapter.submit(
@@ -329,13 +338,19 @@ class Batchwork:
         validate_upload: Callable[[int], None] | None,
     ) -> BatchJob:
         spec = resolve_model(model)
+        validate_batch_metadata(spec.provider, metadata)
         self._validate_requests(requests)
         adapter, resolved_credentials = self._adapter_and_credentials(
             spec.provider, credentials, api_key=api_key, base_url=base_url, headers=headers
         )
         limits = limits or BatchLimits()
         built = build_embedding_bodies(
-            spec.provider, spec.model_id, requests, limits, defaults=defaults
+            spec.provider,
+            spec.model_id,
+            requests,
+            limits,
+            defaults=defaults,
+            strict=True,
         )
         if validate_upload is None:
             snapshot = await adapter.submit(
@@ -399,6 +414,7 @@ class Batchwork:
         validate_upload: Callable[[int], None] | None,
     ) -> BatchJob:
         spec = resolve_model(model)
+        validate_batch_metadata(spec.provider, metadata)
         self._validate_requests(requests)
         adapter, resolved_credentials = self._adapter_and_credentials(
             spec.provider, credentials, api_key=api_key, base_url=base_url, headers=headers

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/job.py

@@ -4,10 +4,12 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import math
 import time
 from collections.abc import AsyncIterator, Awaitable, Callable
 from typing import Protocol, runtime_checkable
 
+from ._read_retry import _ReadRetryDeadlineExceeded, _retry_read
 from .errors import BatchTimeoutError
 from .types import (
     BatchRequestCounts,
@@ -98,10 +100,12 @@ class BatchJob:
         timeout_seconds: float | None,
         on_poll: PollCallback | None,
     ) -> BatchSnapshot:
-        if poll_interval < 0:
-            raise ValueError("poll_interval must be non-negative")
-        if timeout_seconds is not None and timeout_seconds < 0:
-            raise ValueError("timeout must be non-negative")
+        if not math.isfinite(poll_interval) or poll_interval <= 0:
+            raise ValueError("poll_interval must be finite and greater than zero")
+        if timeout_seconds is not None and (
+            not math.isfinite(timeout_seconds) or timeout_seconds < 0
+        ):
+            raise ValueError("timeout must be finite and non-negative")
         deadline = None if timeout_seconds is None else time.monotonic() + timeout_seconds
 
         while True:
@@ -110,14 +114,18 @@ class BatchJob:
                 raise BatchTimeoutError(f'batchwork: timed out waiting for batch "{self.id}"')
 
             if remaining is None:
-                snapshot = await self.poll()
+                snapshot = await _retry_read(self.poll)
                 await _call(on_poll, snapshot)
             else:
                 poll_timeout = asyncio.timeout(remaining)
                 try:
                     async with poll_timeout:
-                        snapshot = await self.poll()
+                        snapshot = await _retry_read(self.poll, deadline=deadline)
                         await _call(on_poll, snapshot)
+                except _ReadRetryDeadlineExceeded:
+                    raise BatchTimeoutError(
+                        f'batchwork: timed out waiting for batch "{self.id}"'
+                    ) from None
                 except TimeoutError:
                     if not poll_timeout.expired():
                         raise
@@ -136,6 +144,10 @@ class BatchJob:
 
     async def results(self) -> AsyncIterator[BatchResult]:
         self._ensure_open()
+        if is_terminal_status(self.status):
+            async for result in self._results_from_current_snapshot():
+                yield result
+            return
         async for result in self._adapter.results(self.id, self._credentials):
             self._ensure_open()
             yield result

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/media.py

@@ -531,7 +531,15 @@ class DefaultMediaResolver:
                                 f"batchwork: media download returned HTTP {response.status_code}"
                             ) from error
                         length = response.headers.get("content-length")
-                        if length is not None and int(length) > max_bytes:
+                        try:
+                            declared_length = int(length) if length is not None else None
+                        except ValueError:
+                            declared_length = None
+                        if (
+                            declared_length is not None
+                            and declared_length >= 0
+                            and declared_length > max_bytes
+                        ):
                             raise _MediaLimitExceededError(
                                 f"batchwork: media exceeds the {max_bytes} byte limit"
                             )

batchwork_ai-0.2.3/src/batchwork/providers/_capabilities.py

@@ -0,0 +1,33 @@
+"""Shared provider capability checks."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from batchwork.errors import _UnsupportedSettingError
+from batchwork.types import BatchProvider
+
+BATCH_METADATA_PROVIDERS = frozenset(
+    {
+        BatchProvider.OPENAI,
+        BatchProvider.GROQ,
+        BatchProvider.MISTRAL,
+        BatchProvider.TOGETHER,
+    }
+)
+
+
+def supports_batch_metadata(provider: BatchProvider) -> bool:
+    """Return whether the provider accepts submission-level batch metadata."""
+
+    return provider in BATCH_METADATA_PROVIDERS
+
+
+def validate_batch_metadata(provider: BatchProvider, metadata: Mapping[str, str] | None) -> None:
+    """Reject unsupported batch metadata before provider-side mutation."""
+
+    if metadata and not supports_batch_metadata(provider):
+        raise _UnsupportedSettingError(
+            f'batchwork: provider "{provider.value}" does not support '
+            "submission-level batch metadata."
+        )

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/providers/anthropic.py

@@ -19,6 +19,7 @@ from batchwork.types import (
     ProviderCredentials,
 )
 
+from ._capabilities import validate_batch_metadata
 from .ids import simple_provider_id
 from .shared import (
     api_key,
@@ -116,7 +117,8 @@ class AnthropicAdapter:
         limits: BatchLimits | None = None,
         validate_upload: Callable[[int], None] | None = None,
     ) -> BatchSnapshot:
-        del endpoint, model_id, metadata
+        validate_batch_metadata(self.id, metadata)
+        del endpoint, model_id
         requests = [
             {
                 "custom_id": item.custom_id,

{batchwork_ai-0.2.2 → batchwork_ai-0.2.3}/src/batchwork/providers/google.py

@@ -19,6 +19,7 @@ from batchwork.types import (
     ProviderCredentials,
 )
 
+from ._capabilities import validate_batch_metadata
 from .ids import prefixed_provider_id
 from .shared import (
     api_key,
@@ -155,7 +156,7 @@ class GoogleAdapter:
         limits: BatchLimits | None = None,
         validate_upload: Callable[[int], None] | None = None,
     ) -> BatchSnapshot:
-        del metadata
+        validate_batch_metadata(self.id, metadata)
         embedding = "embedcontent" in endpoint.lower()
         method = "asyncBatchEmbedContent" if embedding else "batchGenerateContent"
         requests: list[dict[str, object]] = []