structifyai 1.174.0__tar.gz → 1.176.0__tar.gz

structifyai-1.176.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "1.176.0"
+}

{structifyai-1.174.0 → structifyai-1.176.0}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 1.176.0 (2026-01-21)
+
+Full Changelog: [v1.175.0...v1.176.0](https://github.com/StructifyAI/structify-python/compare/v1.175.0...v1.176.0)
+
+### Features
+
+* Update from Structify backend changes ([df41996](https://github.com/StructifyAI/structify-python/commit/df4199667d0dc6e89a1d8da5293fb336f45f589d))
+* Update from Structify backend changes ([6f4c3f5](https://github.com/StructifyAI/structify-python/commit/6f4c3f54df3480734d5dad65bfa9c8f21c1bd53a))
+* Update from Structify backend changes ([f1f2640](https://github.com/StructifyAI/structify-python/commit/f1f264096432818d5174e4b2230adfb789e3f29f))
+
+## 1.175.0 (2026-01-21)
+
+Full Changelog: [v1.174.0...v1.175.0](https://github.com/StructifyAI/structify-python/compare/v1.174.0...v1.175.0)
+
+### Features
+
+* **api:** manual updates ([2e343eb](https://github.com/StructifyAI/structify-python/commit/2e343eb40a99f39efa8a11571f43bf0b3939931c))
+* **api:** manual updates ([d4eaea6](https://github.com/StructifyAI/structify-python/commit/d4eaea6684e7e86176e7240977fc3742f11160ae))
+* Update from Structify backend changes ([7c12fae](https://github.com/StructifyAI/structify-python/commit/7c12fae77216a7f218a91d22c2f6a945d83854ae))
+* Update from Structify backend changes ([ac09e0c](https://github.com/StructifyAI/structify-python/commit/ac09e0c9135311df2f9d0338e31aefd5585a74f2))
+* Update from Structify backend changes ([e74787b](https://github.com/StructifyAI/structify-python/commit/e74787b8cb367c3e03333ff8c9481d0570811f0a))
+* Update from Structify backend changes ([e7cb429](https://github.com/StructifyAI/structify-python/commit/e7cb429c53c01f0306f47a7eeff685d0837b276c))
+
+
+### Chores
+
+* **internal:** update `actions/checkout` version ([61e31a0](https://github.com/StructifyAI/structify-python/commit/61e31a0d4c76caf0a517a7fb820ac706f5c3726d))
+
 ## 1.174.0 (2026-01-17)
 
 Full Changelog: [v1.173.0...v1.174.0](https://github.com/StructifyAI/structify-python/compare/v1.173.0...v1.174.0)

{structifyai-1.174.0 → structifyai-1.176.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: structifyai
-Version: 1.174.0
+Version: 1.176.0
 Summary: The official Python library for the structify API
 Project-URL: Homepage, https://github.com/StructifyAI/structify-python
 Project-URL: Repository, https://github.com/StructifyAI/structify-python

{structifyai-1.174.0 → structifyai-1.176.0}/api.md

@@ -10,6 +10,7 @@ Methods:
 
 - <code title="get /whitelabel/{service}/estimate-cost/{path}">client.whitelabel.<a href="./src/structify/resources/whitelabel.py">estimate_cost</a>(path, \*, service) -> <a href="./src/structify/types/estimate_cost_response.py">EstimateCostResponse</a></code>
 - <code title="get /whitelabel/{service}/{path}">client.whitelabel.<a href="./src/structify/resources/whitelabel.py">proxy_get</a>(path, \*, service) -> None</code>
+- <code title="post /whitelabel/{service}/{path}">client.whitelabel.<a href="./src/structify/resources/whitelabel.py">proxy_post</a>(path, \*, service) -> None</code>
 
 # User
 
@@ -850,7 +851,6 @@ from structify.types import GetSandboxRequest, Sandbox, SandboxListResponse
 
 Methods:
 
-- <code title="post /sandbox/{chat_id}">client.sandbox.<a href="./src/structify/resources/sandbox.py">create</a>(chat_id, \*\*<a href="src/structify/types/sandbox_create_params.py">params</a>) -> <a href="./src/structify/types/sandbox.py">Sandbox</a></code>
 - <code title="get /sandbox/list/{chat_id}">client.sandbox.<a href="./src/structify/resources/sandbox.py">list</a>(chat_id) -> <a href="./src/structify/types/sandbox_list_response.py">SandboxListResponse</a></code>
 - <code title="post /sandbox/live/{chat_id}">client.sandbox.<a href="./src/structify/resources/sandbox.py">get</a>(chat_id, \*\*<a href="src/structify/types/sandbox_get_params.py">params</a>) -> <a href="./src/structify/types/sandbox.py">Sandbox</a></code>
 - <code title="patch /sandbox/{sandbox_id}/status">client.sandbox.<a href="./src/structify/resources/sandbox.py">update_status</a>(sandbox_id, \*\*<a href="src/structify/types/sandbox_update_status_params.py">params</a>) -> <a href="./src/structify/types/sandbox.py">Sandbox</a></code>
@@ -900,6 +900,7 @@ from structify.types import (
     StructureFindRelationshipResponse,
     StructureIsCompleteResponse,
     StructureJobStatusResponse,
+    StructurePdfResponse,
     StructureRunAsyncResponse,
 )
 ```
@@ -911,6 +912,7 @@ Methods:
 - <code title="post /structure/find_relationship">client.structure.<a href="./src/structify/resources/structure.py">find_relationship</a>(\*\*<a href="src/structify/types/structure_find_relationship_params.py">params</a>) -> str</code>
 - <code title="post /structure/is_complete">client.structure.<a href="./src/structify/resources/structure.py">is_complete</a>(\*\*<a href="src/structify/types/structure_is_complete_params.py">params</a>) -> str</code>
 - <code title="post /structure/job_status">client.structure.<a href="./src/structify/resources/structure.py">job_status</a>(\*\*<a href="src/structify/types/structure_job_status_params.py">params</a>) -> <a href="./src/structify/types/structure_job_status_response.py">StructureJobStatusResponse</a></code>
+- <code title="post /structure/pdf">client.structure.<a href="./src/structify/resources/structure.py">pdf</a>(\*\*<a href="src/structify/types/structure_pdf_params.py">params</a>) -> <a href="./src/structify/types/structure_pdf_response.py">StructurePdfResponse</a></code>
 - <code title="post /structure/run_async">client.structure.<a href="./src/structify/resources/structure.py">run_async</a>(\*\*<a href="src/structify/types/structure_run_async_params.py">params</a>) -> str</code>
 
 # PublicSessions

{structifyai-1.174.0 → structifyai-1.176.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "structifyai"
-version = "1.174.0"
+version = "1.176.0"
 description = "The official Python library for the structify API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{structifyai-1.174.0 → structifyai-1.176.0}/src/structify/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "structify"
-__version__ = "1.174.0"  # x-release-please-version
+__version__ = "1.176.0"  # x-release-please-version

{structifyai-1.174.0 → structifyai-1.176.0}/src/structify/resources/polars.py

@@ -30,7 +30,7 @@ from ..lib.cost_confirmation import request_cost_confirmation_if_needed
 from .external_dataframe_proxy import ServicesProxy
 from ..types.save_requirement_param import RequiredEntity, RequiredProperty
 from ..types.dataset_descriptor_param import DatasetDescriptorParam
-from ..types.structure_run_async_params import SourcePdf, SourceWebWeb
+from ..types.structure_run_async_params import SourceWebWeb
 
 __all__ = ["PolarsResource"]
 
@@ -847,6 +847,16 @@ class PolarsResource(SyncAPIResource):
 
         table_param = as_table_param(table_name, schema)
 
+        # Create dataset for this PDF
+        dataset_name = f"structure_pdfs_{table_name}_{uuid.uuid4().hex}"
+        self._client.datasets.create(
+            name=dataset_name,
+            description="",
+            tables=[table_param],
+            relationships=[],
+            ephemeral=True,
+        )
+
         node_id = get_node_id()
 
         # Validate model format if provided as string
@@ -857,9 +867,7 @@ class PolarsResource(SyncAPIResource):
                     "model must be in format 'provider.model_name' (e.g. 'bedrock.claude-sonnet-4-bedrock')"
                 )
 
-        # Build lookups for per-row instructions by index (not by path, since the same PDF may appear multiple times)
         paths_df = document_paths.collect()
-
         instructions_list: list[str | None] = []
 
         if instructions is not None and not isinstance(instructions, str):
@@ -868,108 +876,74 @@ class PolarsResource(SyncAPIResource):
                 raise ValueError(f"instructions shape {instr_df.shape} != document_paths shape {paths_df.shape}")
             instructions_list = cast(List[Optional[str]], instr_df[instr_df.columns[0]].to_list())
 
-        def structure_batch(batch_df: pl.DataFrame) -> pl.DataFrame:
-            # Track by row index since the same PDF may appear multiple times with different instructions
-            batch_rows = batch_df.with_row_index("__row_idx__").to_dicts()
-            valid_rows = [row for row in batch_rows if row.get(path_column) is not None]
-
-            if not valid_rows:
-                return pl.DataFrame(schema=polars_schema)
+        # Request cost confirmation before dispatching costly PDF extraction jobs
+        if not request_cost_confirmation_if_needed(self._client, paths_df.shape[0]):
+            raise Exception(f"User cancelled PDF extraction for {table_name}")
 
-            # Request cost confirmation before dispatching costly PDF extraction jobs
-            if not request_cost_confirmation_if_needed(self._client, len(valid_rows)):
-                raise Exception(f"User cancelled PDF extraction for {table_name}")
+        job_to_pdf_path: dict[str, str] = {}
 
-            # Process each PDF document
-            job_ids: list[str] = []
-            idx_to_dataset: dict[int, str] = {}
-
-            def process_pdf(row: dict[str, Any]) -> Tuple[str, int, str]:
-                row_idx = row["__row_idx__"]
-                pdf_path = row[path_column]
-                dataset_name = f"structure_pdfs_{table_name}_{uuid.uuid4().hex}"
-
-                # Create dataset for this PDF
-                self._client.datasets.create(
-                    name=dataset_name,
-                    description="",
-                    tables=[table_param],
-                    relationships=[],
-                    ephemeral=True,
-                )
-
-                # Upload the PDF document
-                with open(pdf_path, "rb") as pdf_file:
+        # Process each PDF document
+        def process_pdf(pdf_path: str, instructions: str | None) -> Tuple[List[str], str]:
+            # Upload the PDF document
+            unique_pdf_name = f"{uuid.uuid4().hex}.pdf"
+            with open(pdf_path, "rb") as pdf_file:
+                try:
                     self._client.documents.upload(
                         content=pdf_file,
                         file_type="PDF",
                         dataset=dataset_name,
-                        path=f"{dataset_name}.pdf".encode(),
+                        path=unique_pdf_name.encode(),
                     )
-
-                # Get per-row instructions and model
+                except Exception as e:
+                    if "Document already exists" not in str(e):
+                        raise e
+
+            job_ids = self._client.structure.pdf(
+                dataset=dataset_name,
+                path=unique_pdf_name,
+                node_id=node_id,
+                instructions=instructions,
+                mode="Single" if mode == "single" else "Batch",
+                model=model,
+            ).job_ids
+            return job_ids, pdf_path
+
+        with ThreadPoolExecutor(max_workers=MAX_PARALLEL_REQUESTS) as executor:
+            futures: List[Future[Tuple[List[str], str]]] = []
+            for i in range(paths_df.shape[0]):
+                path: str | None = paths_df[path_column][i]
                 pdf_instructions: str | None = None
                 if isinstance(instructions, str):
                     pdf_instructions = instructions
                 elif instructions_list:
-                    pdf_instructions = cast(Optional[str], instructions_list[row_idx])
-                elif conditioning:
+                    pdf_instructions = instructions_list[i]
+                if pdf_instructions is None and conditioning:
                     pdf_instructions = conditioning
+                if path is not None:
+                    futures.append(executor.submit(process_pdf, path, pdf_instructions))
+            for future in tqdm(as_completed(futures), total=len(futures), desc="Preparing PDFs"):
+                job_ids, pdf_path = future.result()
+                for job_id in job_ids:
+                    job_to_pdf_path[job_id] = pdf_path
+
+        # Wait for all PDF processing jobs to complete
+        self._client.jobs.wait_for_jobs(dataset_name=dataset_name, title=f"Parsing PDFs", node_id=node_id)
+
+        # Get all of the entities with their job_ids
+        entities = self._client.datasets.view_table(dataset=dataset_name, name=table_name)
+        structured_results: List[Dict[str, Any]] = [
+            {**entity.properties, path_column: job_to_pdf_path[entity.job_ids[0]]} for entity in entities
+        ]
 
-                job_id = self._client.structure.run_async(
-                    dataset=dataset_name,
-                    source=SourcePdf(pdf={"path": f"{dataset_name}.pdf", "single_agent": mode == "single"}),
-                    node_id=node_id,
-                    instructions=pdf_instructions,
-                    model=model,
-                )
-                return job_id, row_idx, dataset_name
-
-            with ThreadPoolExecutor(max_workers=MAX_PARALLEL_REQUESTS) as executor:
-                futures = [executor.submit(process_pdf, row) for row in valid_rows]
-                for future in tqdm(as_completed(futures), total=len(futures), desc="Preparing PDFs"):
-                    job_id, row_idx, dataset_name = future.result()
-                    job_ids.append(job_id)
-                    idx_to_dataset[row_idx] = dataset_name
-
-            # Wait for all PDF processing jobs to complete
-            self._client.jobs.wait_for_jobs(job_ids=job_ids, title=f"Parsing {table_name} from PDFs", node_id=node_id)
-
-            # Collect results from all processed PDFs - each result is tagged with its source row_idx
-            structured_results: list[dict[str, Any]] = []
-
-            def collect_pdf_results(row_idx: int, dataset_name: str) -> List[Dict[str, Any]]:
-                pdf_path = batch_rows[row_idx][path_column]
-                entities_result = self._client.datasets.view_table(dataset=dataset_name, name=table_name)
-                return [
-                    {**entity.properties, path_column: pdf_path, "__row_idx__": row_idx} for entity in entities_result
-                ]
-
-            with ThreadPoolExecutor(max_workers=MAX_PARALLEL_REQUESTS) as executor:
-                collect_futures = [
-                    executor.submit(collect_pdf_results, row_idx, dataset_name)
-                    for row_idx, dataset_name in idx_to_dataset.items()
-                ]
-                for future in tqdm(
-                    as_completed(collect_futures), total=len(collect_futures), desc="Collecting PDF extractions"
-                ):
-                    results = future.result()
-                    structured_results.extend(results)
-
-            # Ensure all columns are present with None for missing values
-            for result_row in structured_results:
-                for col_name in polars_schema.names():
-                    if col_name not in result_row:
-                        result_row[col_name] = None
-
-            if not structured_results:
-                return pl.DataFrame(schema=polars_schema)
-
-            # Build result dataframe directly from structured_results without joining
-            # Each entity is already tagged with path_column from its source PDF
-            return pl.DataFrame(structured_results, schema=polars_schema)
+        # Ensure all columns are present with None for missing values
+        for result_row in structured_results:
+            for col_name in polars_schema.names():
+                if col_name not in result_row:
+                    result_row[col_name] = None
 
-        return document_paths.map_batches(structure_batch, schema=polars_schema, no_optimizations=True)
+        # Build result dataframe directly from structured_results without joining
+        # Each entity is already tagged with path_column from its source PDF
+        return pl.DataFrame(structured_results, schema=polars_schema).lazy()
 
     def tag(
         self,

{structifyai-1.174.0 → structifyai-1.176.0}/src/structify/resources/sandbox.py

@@ -3,11 +3,10 @@
 from __future__ import annotations
 
 from typing import Optional
-from typing_extensions import Literal
 
 import httpx
 
-from ..types import sandbox_get_params, sandbox_create_params, sandbox_update_status_params
+from ..types import sandbox_get_params, sandbox_update_status_params
 from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
 from .._utils import maybe_transform, async_maybe_transform
 from .._compat import cached_property
@@ -45,54 +44,6 @@ class SandboxResource(SyncAPIResource):
         """
         return SandboxResourceWithStreamingResponse(self)
 
-    def create(
-        self,
-        chat_id: str,
-        *,
-        chat_session_id: str,
-        modal_id: str,
-        modal_url: str,
-        status: Literal["alive", "terminated"],
-        latest_node: Optional[str] | Omit = omit,
-        session_id: Optional[str] | Omit = omit,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> Sandbox:
-        """
-        Args:
-          extra_headers: Send extra headers
-
-          extra_query: Add additional query parameters to the request
-
-          extra_body: Add additional JSON properties to the request
-
-          timeout: Override the client-level default timeout for this request, in seconds
-        """
-        if not chat_id:
-            raise ValueError(f"Expected a non-empty value for `chat_id` but received {chat_id!r}")
-        return self._post(
-            f"/sandbox/{chat_id}",
-            body=maybe_transform(
-                {
-                    "chat_session_id": chat_session_id,
-                    "modal_id": modal_id,
-                    "modal_url": modal_url,
-                    "status": status,
-                    "latest_node": latest_node,
-                    "session_id": session_id,
-                },
-                sandbox_create_params.SandboxCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Sandbox,
-        )
-
     def list(
         self,
         chat_id: str,
@@ -216,54 +167,6 @@ class AsyncSandboxResource(AsyncAPIResource):
         """
         return AsyncSandboxResourceWithStreamingResponse(self)
 
-    async def create(
-        self,
-        chat_id: str,
-        *,
-        chat_session_id: str,
-        modal_id: str,
-        modal_url: str,
-        status: Literal["alive", "terminated"],
-        latest_node: Optional[str] | Omit = omit,
-        session_id: Optional[str] | Omit = omit,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> Sandbox:
-        """
-        Args:
-          extra_headers: Send extra headers
-
-          extra_query: Add additional query parameters to the request
-
-          extra_body: Add additional JSON properties to the request
-
-          timeout: Override the client-level default timeout for this request, in seconds
-        """
-        if not chat_id:
-            raise ValueError(f"Expected a non-empty value for `chat_id` but received {chat_id!r}")
-        return await self._post(
-            f"/sandbox/{chat_id}",
-            body=await async_maybe_transform(
-                {
-                    "chat_session_id": chat_session_id,
-                    "modal_id": modal_id,
-                    "modal_url": modal_url,
-                    "status": status,
-                    "latest_node": latest_node,
-                    "session_id": session_id,
-                },
-                sandbox_create_params.SandboxCreateParams,
-            ),
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=Sandbox,
-        )
-
     async def list(
         self,
         chat_id: str,
@@ -373,9 +276,6 @@ class SandboxResourceWithRawResponse:
     def __init__(self, sandbox: SandboxResource) -> None:
         self._sandbox = sandbox
 
-        self.create = to_raw_response_wrapper(
-            sandbox.create,
-        )
         self.list = to_raw_response_wrapper(
             sandbox.list,
         )
@@ -391,9 +291,6 @@ class AsyncSandboxResourceWithRawResponse:
     def __init__(self, sandbox: AsyncSandboxResource) -> None:
         self._sandbox = sandbox
 
-        self.create = async_to_raw_response_wrapper(
-            sandbox.create,
-        )
         self.list = async_to_raw_response_wrapper(
             sandbox.list,
         )
@@ -409,9 +306,6 @@ class SandboxResourceWithStreamingResponse:
     def __init__(self, sandbox: SandboxResource) -> None:
         self._sandbox = sandbox
 
-        self.create = to_streamed_response_wrapper(
-            sandbox.create,
-        )
         self.list = to_streamed_response_wrapper(
             sandbox.list,
         )
@@ -427,9 +321,6 @@ class AsyncSandboxResourceWithStreamingResponse:
     def __init__(self, sandbox: AsyncSandboxResource) -> None:
         self._sandbox = sandbox
 
-        self.create = async_to_streamed_response_wrapper(
-            sandbox.create,
-        )
         self.list = async_to_streamed_response_wrapper(
             sandbox.list,
         )

{structifyai-1.174.0 → structifyai-1.176.0}/src/structify/resources/sessions.py

@@ -483,6 +483,7 @@ class SessionsResource(SyncAPIResource):
         self,
         node_id: str,
         *,
+        operation: Literal["tag", "pdf", "web", "match"],
         row_count: int,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -506,7 +507,11 @@ class SessionsResource(SyncAPIResource):
         return self._post(
             f"/sessions/nodes/{node_id}/request_confirmation",
             body=maybe_transform(
-                {"row_count": row_count}, session_request_confirmation_params.SessionRequestConfirmationParams
+                {
+                    "operation": operation,
+                    "row_count": row_count,
+                },
+                session_request_confirmation_params.SessionRequestConfirmationParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
@@ -1145,6 +1150,7 @@ class AsyncSessionsResource(AsyncAPIResource):
         self,
         node_id: str,
         *,
+        operation: Literal["tag", "pdf", "web", "match"],
         row_count: int,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -1168,7 +1174,11 @@ class AsyncSessionsResource(AsyncAPIResource):
         return await self._post(
             f"/sessions/nodes/{node_id}/request_confirmation",
             body=await async_maybe_transform(
-                {"row_count": row_count}, session_request_confirmation_params.SessionRequestConfirmationParams
+                {
+                    "operation": operation,
+                    "row_count": row_count,
+                },
+                session_request_confirmation_params.SessionRequestConfirmationParams,
             ),
             options=make_request_options(
                 extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout

{structifyai-1.174.0 → structifyai-1.176.0}/src/structify/resources/structure.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 from typing import Iterable, Optional
+from typing_extensions import Literal
 
 import httpx
 
 from ..types import (
+    structure_pdf_params,
     structure_run_async_params,
     structure_job_status_params,
     structure_enhance_property_params,
@@ -26,6 +28,7 @@ from .._response import (
 from .._base_client import make_request_options
 from ..types.knowledge_graph_param import KnowledgeGraphParam
 from ..types.save_requirement_param import SaveRequirementParam
+from ..types.structure_pdf_response import StructurePdfResponse
 from ..types.structure_job_status_response import StructureJobStatusResponse
 
 __all__ = ["StructureResource", "AsyncStructureResource"]
@@ -267,6 +270,55 @@ class StructureResource(SyncAPIResource):
             cast_to=StructureJobStatusResponse,
         )
 
+    def pdf(
+        self,
+        *,
+        dataset: str,
+        path: str,
+        instructions: Optional[str] | Omit = omit,
+        mode: Literal["Single", "Batch"] | Omit = omit,
+        model: Optional[str] | Omit = omit,
+        node_id: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> StructurePdfResponse:
+        """For single mode, creates one job for the entire PDF.
+
+        For batch mode, creates one
+        job per PDF page.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/structure/pdf",
+            body=maybe_transform(
+                {
+                    "dataset": dataset,
+                    "path": path,
+                    "instructions": instructions,
+                    "mode": mode,
+                    "model": model,
+                    "node_id": node_id,
+                },
+                structure_pdf_params.StructurePdfParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=StructurePdfResponse,
+        )
+
     def run_async(
         self,
         *,
@@ -560,6 +612,55 @@ class AsyncStructureResource(AsyncAPIResource):
             cast_to=StructureJobStatusResponse,
         )
 
+    async def pdf(
+        self,
+        *,
+        dataset: str,
+        path: str,
+        instructions: Optional[str] | Omit = omit,
+        mode: Literal["Single", "Batch"] | Omit = omit,
+        model: Optional[str] | Omit = omit,
+        node_id: Optional[str] | Omit = omit,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> StructurePdfResponse:
+        """For single mode, creates one job for the entire PDF.
+
+        For batch mode, creates one
+        job per PDF page.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/structure/pdf",
+            body=await async_maybe_transform(
+                {
+                    "dataset": dataset,
+                    "path": path,
+                    "instructions": instructions,
+                    "mode": mode,
+                    "model": model,
+                    "node_id": node_id,
+                },
+                structure_pdf_params.StructurePdfParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=StructurePdfResponse,
+        )
+
     async def run_async(
         self,
         *,
@@ -636,6 +737,9 @@ class StructureResourceWithRawResponse:
         self.job_status = to_raw_response_wrapper(
             structure.job_status,
         )
+        self.pdf = to_raw_response_wrapper(
+            structure.pdf,
+        )
         self.run_async = to_raw_response_wrapper(
             structure.run_async,
         )
@@ -660,6 +764,9 @@ class AsyncStructureResourceWithRawResponse:
         self.job_status = async_to_raw_response_wrapper(
             structure.job_status,
         )
+        self.pdf = async_to_raw_response_wrapper(
+            structure.pdf,
+        )
         self.run_async = async_to_raw_response_wrapper(
             structure.run_async,
         )
@@ -684,6 +791,9 @@ class StructureResourceWithStreamingResponse:
         self.job_status = to_streamed_response_wrapper(
             structure.job_status,
         )
+        self.pdf = to_streamed_response_wrapper(
+            structure.pdf,
+        )
         self.run_async = to_streamed_response_wrapper(
             structure.run_async,
         )
@@ -708,6 +818,9 @@ class AsyncStructureResourceWithStreamingResponse:
         self.job_status = async_to_streamed_response_wrapper(
             structure.job_status,
         )
+        self.pdf = async_to_streamed_response_wrapper(
+            structure.pdf,
+        )
         self.run_async = async_to_streamed_response_wrapper(
             structure.run_async,
         )