dex-connector-docusign 0.1.0__tar.gz

dex_connector_docusign-0.1.0/.gitignore

@@ -0,0 +1,16 @@
+.DS_Store
+__pycache__/
+*.py[cod]
+node_modules/
+dist/
+sdkpython/dist/dex_connectors_sdk-0.1.0-py3-none-any.whl
+/.bin/dexcli
+/.bin/dex-server-zd
+/sdkpython/.dexcli-data/
+site/.catalog.yaml
+coverage/
+*.out
+*.test
+go.work
+go.work.sum
+.idea/

dex_connector_docusign-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Super Durable
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dex_connector_docusign-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: dex-connector-docusign
+Version: 0.1.0
+Summary: DocuSign eSignature connector for Dex Flows
+Project-URL: Source, https://github.com/superdurable/dex-connectors-library/tree/main/connectors/docusign/python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: dex-connectors-sdk==0.7.0
+Requires-Dist: dex-python-sdk>=1.28.0
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# DocuSign eSignature Python connector
+
+This package implements `createEnvelopeFromTemplate`, `getEnvelope`,
+`listEnvelopeRecipients`, `voidEnvelope`, and `downloadCombinedDocument` for
+Dex Python Flows. The `envelopeEventReceived` Connect Trigger remains Go-only.
+The manifest owns operation identities, retry policies, branches, configuration,
+and OAuth methods. The Python package version is `v0.1.0` and requires
+`dex-connectors-sdk==0.7.0`.
+
+`new_project_connection` loads the static connection name from Dex project
+configuration. It uses the generated OAuth credential decoder and refresh
+driver for production and developer accounts. Each provider call resolves the
+current access token, reads `/oauth/userinfo` to choose the account and regional
+API host, and rejects a host outside the selected environment. The PDF operation
+returns a digest, byte count, and optional store location; PDF bytes never enter
+a Dex Result. `CombinedDocumentStore` accepts bounded PDF bytes outside Dex and
+must be idempotent and atomic.
+
+## Runnable example
+
+[`examples/envelope_status/flow.py`](examples/envelope_status/flow.py) reads
+an envelope with the static `docusign-esignature` connection. It persists only
+the request and safe envelope summary. Its optional `notFound`,
+`providerRejected`, `invalidResponse`, and `defect` branches are intentionally
+unwired, so Dex fails the Flow if one is selected.
+
+From `connectors/docusign/python`, install dependencies and produce a strict
+FDG 2.0 file for Dex Web:
+
+```sh
+uv sync --locked
+dexcli visualize examples/envelope_status/flow.py --language python \
+  --schema-version 2.0 --lint app --json --out build/envelope-status \
+  --python .venv/bin/python
+```
+
+Start `dexcli dev` with that rendering directory. In Dex Web **Connections**,
+create `docusign / docusign-esignature`, choose Production account or Developer
+account, and follow the authorization guide in the connector manifest. Register
+Dex Web's exact redirect URI in the DocuSign app. The OAuth scopes are
+`signature` and `extended`; Dex handles access and refresh tokens. The account
+ID may stay blank to use the authorizing user's default account. A Connect HMAC
+key is optional for this read-only example. Use the owner-only
+`connections.json` exported by Dex Web as `DEX_CONNECTOR_CONFIG_FILE`.
+
+Run the Worker and start a Flow with the included sample input:
+
+```sh
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+DEX_CONNECTOR_CONFIG_FILE=/path/to/connections.json \
+uv run python -m examples.envelope_status.main
+
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+DEX_CONNECTOR_CONFIG_FILE=/path/to/connections.json \
+uv run python -m examples.envelope_status.start \
+  docusign-envelope-001 examples/envelope_status/sample-input.json
+```
+
+The Worker binding in [`main.py`](examples/envelope_status/main.py) is the
+application entrypoint:
+
+```python
+project = await load_from_environment()
+connection = new_project_connection(project, CONNECTION_NAME)
+try:
+    await run_worker(EnvelopeStatusFlow(connection))
+finally:
+    await connection.aclose()
+    await project.close()
+```
+
+Run the real Dex integration test against a local `dexcli dev` server:
+
+```sh
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+uv run pytest examples/envelope_status/integration_test.py
+```
+
+The test binds its HTTP provider stand-in to an OS-assigned free port. It checks
+retry after a 429 and failure on an unwired `notFound` branch through a real Dex
+Worker and Client. The 52 Go-recorded conformance scenarios exercise every
+operation's provider requests and exact SDK-encoded outputs. OAuth refresh
+agreement has its own generated Go and Python suites.
+
+Live DocuSign authorization, account selection, regional host resolution,
+provider error codes, envelope read-back timing, PDF downloads, and Connect
+configuration have not been verified with a real DocuSign account.

dex_connector_docusign-0.1.0/README.md

@@ -0,0 +1,87 @@
+# DocuSign eSignature Python connector
+
+This package implements `createEnvelopeFromTemplate`, `getEnvelope`,
+`listEnvelopeRecipients`, `voidEnvelope`, and `downloadCombinedDocument` for
+Dex Python Flows. The `envelopeEventReceived` Connect Trigger remains Go-only.
+The manifest owns operation identities, retry policies, branches, configuration,
+and OAuth methods. The Python package version is `v0.1.0` and requires
+`dex-connectors-sdk==0.7.0`.
+
+`new_project_connection` loads the static connection name from Dex project
+configuration. It uses the generated OAuth credential decoder and refresh
+driver for production and developer accounts. Each provider call resolves the
+current access token, reads `/oauth/userinfo` to choose the account and regional
+API host, and rejects a host outside the selected environment. The PDF operation
+returns a digest, byte count, and optional store location; PDF bytes never enter
+a Dex Result. `CombinedDocumentStore` accepts bounded PDF bytes outside Dex and
+must be idempotent and atomic.
+
+## Runnable example
+
+[`examples/envelope_status/flow.py`](examples/envelope_status/flow.py) reads
+an envelope with the static `docusign-esignature` connection. It persists only
+the request and safe envelope summary. Its optional `notFound`,
+`providerRejected`, `invalidResponse`, and `defect` branches are intentionally
+unwired, so Dex fails the Flow if one is selected.
+
+From `connectors/docusign/python`, install dependencies and produce a strict
+FDG 2.0 file for Dex Web:
+
+```sh
+uv sync --locked
+dexcli visualize examples/envelope_status/flow.py --language python \
+  --schema-version 2.0 --lint app --json --out build/envelope-status \
+  --python .venv/bin/python
+```
+
+Start `dexcli dev` with that rendering directory. In Dex Web **Connections**,
+create `docusign / docusign-esignature`, choose Production account or Developer
+account, and follow the authorization guide in the connector manifest. Register
+Dex Web's exact redirect URI in the DocuSign app. The OAuth scopes are
+`signature` and `extended`; Dex handles access and refresh tokens. The account
+ID may stay blank to use the authorizing user's default account. A Connect HMAC
+key is optional for this read-only example. Use the owner-only
+`connections.json` exported by Dex Web as `DEX_CONNECTOR_CONFIG_FILE`.
+
+Run the Worker and start a Flow with the included sample input:
+
+```sh
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+DEX_CONNECTOR_CONFIG_FILE=/path/to/connections.json \
+uv run python -m examples.envelope_status.main
+
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+DEX_CONNECTOR_CONFIG_FILE=/path/to/connections.json \
+uv run python -m examples.envelope_status.start \
+  docusign-envelope-001 examples/envelope_status/sample-input.json
+```
+
+The Worker binding in [`main.py`](examples/envelope_status/main.py) is the
+application entrypoint:
+
+```python
+project = await load_from_environment()
+connection = new_project_connection(project, CONNECTION_NAME)
+try:
+    await run_worker(EnvelopeStatusFlow(connection))
+finally:
+    await connection.aclose()
+    await project.close()
+```
+
+Run the real Dex integration test against a local `dexcli dev` server:
+
+```sh
+DEX_FLOW_SERVICE_ADDRESS=127.0.0.1:40901 \
+uv run pytest examples/envelope_status/integration_test.py
+```
+
+The test binds its HTTP provider stand-in to an OS-assigned free port. It checks
+retry after a 429 and failure on an unwired `notFound` branch through a real Dex
+Worker and Client. The 52 Go-recorded conformance scenarios exercise every
+operation's provider requests and exact SDK-encoded outputs. OAuth refresh
+agreement has its own generated Go and Python suites.
+
+Live DocuSign authorization, account selection, regional host resolution,
+provider error codes, envelope read-back timing, PDF downloads, and Connect
+configuration have not been verified with a real DocuSign account.

dex_connector_docusign-0.1.0/examples/envelope_status/README.md

@@ -0,0 +1,7 @@
+# Envelope status example
+
+Run the strict FDG 2.0 generation, Dex Web connection setup, Worker, Client
+start command, and real Dex integration test in the
+[Python package README](../../README.md#runnable-example). The Flow uses
+`docusign-esignature` and the `getEnvelope` Query. Its optional branches fail
+the Flow when selected.

dex_connector_docusign-0.1.0/examples/envelope_status/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""DocuSign envelope status example."""

dex_connector_docusign-0.1.0/examples/envelope_status/flow.py

@@ -0,0 +1,76 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Read a DocuSign envelope through one durable Dex Query Step."""
+
+import dex
+from dex_connectors.sdk import QueryResult
+
+from dex_connectors.docusign import Connection, Envelope, GetEnvelopeInput, new_get_envelope_step
+
+CONNECTION_NAME = "docusign-esignature"
+FLOW_TYPE = "DocuSignEnvelopeStatusPython"
+_OPERATION_STEP_TYPE = "GetDocuSignEnvelope"
+_REQUEST = dex.Attribute("docusign-python-envelope-request", GetEnvelopeInput)
+_ENVELOPE = dex.Attribute("docusign-python-envelope", Envelope)
+
+
+def map_to_operation_input(request: GetEnvelopeInput) -> GetEnvelopeInput:
+    """Pass the typed request to the provider operation."""
+    return request
+
+
+# dex:group group-id:docusign-envelope group-label:"DocuSign envelope"
+# dex:explanation text:"Persist the envelope ID before reading DocuSign."
+class _StartEnvelopeStatus(dex.Step[GetEnvelopeInput]):
+    def get_step_type(self) -> str:
+        return "StartDocuSignEnvelopeStatus"
+
+    def execute(self, context: dex.Context, input: GetEnvelopeInput) -> dex.StepDecision:
+        _REQUEST.set(context, input)
+        return dex.go_to(dex.StepRef("GetDocuSignEnvelope"), input)
+
+
+# dex:group group-id:docusign-envelope group-label:"DocuSign envelope"
+# dex:explanation text:"Persist the envelope status without secret or document bytes."
+class _CompleteEnvelopeStatus(dex.Step[QueryResult[Envelope]]):
+    def get_step_type(self) -> str:
+        return "CompleteDocuSignEnvelopeStatus"
+
+    def execute(self, context: dex.Context, input: QueryResult[Envelope]) -> dex.StepDecision:
+        _ENVELOPE.set(context, input.value)
+        return dex.graceful_complete(input.value)
+
+
+class EnvelopeStatusFlow(dex.Flow[GetEnvelopeInput]):
+    """Read one envelope through the static DocuSign connection."""
+
+    def __init__(self, connection: Connection) -> None:
+        if connection.reference.name != CONNECTION_NAME:
+            raise ValueError("envelope status requires the static DocuSign connection")
+        self._start = _StartEnvelopeStatus()
+        self._complete = _CompleteEnvelopeStatus()
+        self._get = new_get_envelope_step(
+            step_type=_OPERATION_STEP_TYPE,
+            step_input_type=GetEnvelopeInput,
+            annotations={
+                "groupId": "docusign-envelope",
+                "groupLabel": "DocuSign envelope",
+                "explanation": "Read the envelope status and text custom fields from DocuSign.",
+            },
+            connection=connection,
+            connection_name=CONNECTION_NAME,
+            map_to_operation_input=map_to_operation_input,
+            found=self._complete,
+        )
+
+    def get_flow_type(self) -> str:
+        """Return this example's stable Flow identity."""
+        return "DocuSignEnvelopeStatusPython"
+
+    def get_steps(self) -> dex.StepList[GetEnvelopeInput]:
+        """Register the start, provider query, and completion Steps."""
+        return dex.StepList.start_step(self._start).other_steps(self._get, self._complete)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        """Register both durable, non-secret Attributes."""
+        return dex.PersistenceSchema.of(_REQUEST, _ENVELOPE)

dex_connector_docusign-0.1.0/examples/envelope_status/integration_test.py

@@ -0,0 +1,197 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Verify the example through a real Dex Worker, Client, retry, and branch route."""
+
+import asyncio
+import json
+import os
+import tempfile
+import threading
+from datetime import timedelta
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import urlsplit
+from uuid import uuid4
+
+import dex
+import httpx
+import pytest
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.docusign import Envelope, GetEnvelopeInput, new_project_connection
+
+from .flow import CONNECTION_NAME, EnvelopeStatusFlow
+
+ACCOUNT_ID = "a4ec37d6-1111-2222-3333-143885c220e1"
+ENVELOPE_ID = "93be49ab-1111-2222-3333-f752070d71ec"
+
+
+class _ProviderStandIn(BaseHTTPRequestHandler):
+    requests: list[str] = []
+
+    def do_GET(self) -> None:
+        """Serve one account, a rate limited first read, and a later envelope."""
+        self.requests.append(self.path)
+        body: dict[str, object]
+        if urlsplit(self.path).path == "/oauth/userinfo":
+            status, body = (
+                200,
+                {
+                    "accounts": [
+                        {"account_id": ACCOUNT_ID, "is_default": True, "base_uri": "https://na3.docusign.net"}
+                    ]
+                },
+            )
+        elif "000000000404" in self.path:
+            status, body = 404, {"errorCode": "ENVELOPE_DOES_NOT_EXIST"}
+        elif sum("/envelopes/" in path and ENVELOPE_ID in path for path in self.requests) == 1:
+            status, body = 429, {"errorCode": "RATE_LIMITED"}
+        else:
+            status, body = (
+                200,
+                {
+                    "envelopeId": ENVELOPE_ID,
+                    "status": "completed",
+                    "completedDateTime": "2026-10-04T12:00:00Z",
+                },
+            )
+        encoded = json.dumps(body).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    def do_POST(self) -> None:
+        """Refresh an inert OAuth token using the manifest's generated driver."""
+        self.requests.append(self.path)
+        length = int(self.headers.get("Content-Length", "0"))
+        self.rfile.read(length)
+        encoded = json.dumps(
+            {
+                "access_token": "inert-refreshed-access-token",
+                "refresh_token": "inert-refreshed-refresh-token",
+                "token_type": "Bearer",
+                "scope": "signature extended",
+                "expires_in": 3600,
+            }
+        ).encode()
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(encoded)))
+        self.end_headers()
+        self.wfile.write(encoded)
+
+    def log_message(self, _format: str, *args: object) -> None:
+        """Keep the test log free of request headers."""
+
+
+class _LocalProviderTransport(httpx.AsyncBaseTransport):
+    def __init__(self, port: int) -> None:
+        self.port = port
+        self.transport = httpx.AsyncHTTPTransport()
+
+    async def handle_async_request(self, request: httpx.Request) -> httpx.Response:
+        """Preserve the provider path while sending bytes to the local stand-in."""
+        local_url = f"http://127.0.0.1:{self.port}{request.url.raw_path.decode()}"
+        headers = [(name, value) for name, value in request.headers.raw if name.lower() != b"host"]
+        local_request = httpx.Request(
+            request.method, local_url, headers=headers, content=await request.aread()
+        )
+        return await self.transport.handle_async_request(local_request)
+
+    async def aclose(self) -> None:
+        """Close the owned HTTP transport."""
+        await self.transport.aclose()
+
+
+@pytest.mark.asyncio
+async def test_envelope_status_retries_and_fails_unwired_not_found(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Route the happy path and optional failure through Dex persistence."""
+    server_address = os.environ["DEX_FLOW_SERVICE_ADDRESS"]
+    _ProviderStandIn.requests = []
+    provider = ThreadingHTTPServer(("127.0.0.1", 0), _ProviderStandIn)
+    server_thread = threading.Thread(target=provider.serve_forever, daemon=True)
+    server_thread.start()
+    try:
+        async with httpx.AsyncClient(
+            transport=_LocalProviderTransport(provider.server_port)
+        ) as provider_http:
+            with tempfile.TemporaryDirectory(prefix="docusign-python-dex-") as directory:
+                connections_path = Path(directory) / "connections.json"
+                connections_path.write_text(
+                    json.dumps(
+                        {
+                            "schemaVersion": "connectors.dex.dev/local-connections/v1alpha1",
+                            "connections": [
+                                {
+                                    "connectorId": "docusign",
+                                    "connectionName": CONNECTION_NAME,
+                                    "modulePath": (
+                                        "github.com/superdurable/dex-connectors-library/"
+                                        "connectors/docusign"
+                                    ),
+                                    "provider": "docusign",
+                                    "authMethodId": "docusign-oauth",
+                                    "configuration": {},
+                                    "credentials": {
+                                        "oauth_client_id": "inert-integration-key",
+                                        "oauth_client_secret": "inert-client-secret",
+                                        "access_token": "inert-access-token",
+                                        "refresh_token": "inert-refresh-token",
+                                    },
+                                }
+                            ],
+                            "triggerBindings": [],
+                        }
+                    )
+                )
+                connections_path.chmod(0o600)
+                monkeypatch.setenv("DEX_CONNECTOR_CONFIG_FILE", str(connections_path))
+                project = await load_from_environment()
+                connection = new_project_connection(project, CONNECTION_NAME, provider_http)
+                flow = EnvelopeStatusFlow(connection)
+                registry = dex.Registry([flow], allow_async_handlers=True)
+                cache = dex.open_blob_cache(dex.BlobCacheConfig(str(Path(directory) / "blobs"), 1 << 24))
+                try:
+                    worker = dex.AsyncWorker(
+                        registry, cache, dex.WorkerOptions(server_address=server_address)
+                    )
+                    worker_task = asyncio.create_task(worker.start())
+                    try:
+                        await worker.wait_pull_registered(timeout=15)
+                        async with dex.AsyncClient(
+                            registry, cache, dex.ClientOptions(server_address=server_address)
+                        ) as dex_client:
+                            flow_id = f"docusign-python-{uuid4().hex}"
+                            await dex_client.start_flow(flow, flow_id, GetEnvelopeInput(ENVELOPE_ID))
+                            result = await asyncio.wait_for(
+                                dex_client.wait_for_flow(flow_id, timedelta(seconds=30)), 40
+                            )
+                            assert result.status == dex.FlowStatus.COMPLETED, result.error_message
+                            assert result.single_output(Envelope).status == "completed"
+                            assert "/oauth/token" in _ProviderStandIn.requests
+                            assert sum(ENVELOPE_ID in path for path in _ProviderStandIn.requests) == 2
+
+                            missing_id = "93be49ab-1111-2222-3333-000000000404"
+                            failed_id = f"docusign-python-{uuid4().hex}"
+                            await dex_client.start_flow(flow, failed_id, GetEnvelopeInput(missing_id))
+                            failed = await asyncio.wait_for(
+                                dex_client.wait_for_flow(failed_id, timedelta(seconds=30)), 40
+                            )
+                            assert failed.status == dex.FlowStatus.FAILED
+                            assert failed.error_message is not None
+                            assert "notFound" in failed.error_message
+                    finally:
+                        await worker.stop()
+                        await worker_task
+                finally:
+                    cache.close()
+                await connection.aclose()
+                await project.close()
+    finally:
+        provider.shutdown()
+        provider.server_close()
+        server_thread.join(timeout=5)

dex_connector_docusign-0.1.0/examples/envelope_status/main.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Load the DocuSign project connection and run the example Worker."""
+
+import asyncio
+
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.docusign import new_project_connection
+
+from .flow import CONNECTION_NAME, EnvelopeStatusFlow
+from .worker import run_worker
+
+
+async def main() -> None:
+    """Bind the user-managed connection before Worker registration."""
+    project = await load_from_environment()
+    connection = new_project_connection(project, CONNECTION_NAME)
+    try:
+        await run_worker(EnvelopeStatusFlow(connection))
+    finally:
+        await connection.aclose()
+        await project.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

dex_connector_docusign-0.1.0/examples/envelope_status/sample-input.json

@@ -0,0 +1 @@
+{"envelopeId":"93be49ab-1111-2222-3333-f752070d71ec"}

dex_connector_docusign-0.1.0/examples/envelope_status/start.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Start the DocuSign envelope status Flow with a unique Flow ID."""
+
+import argparse
+import asyncio
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+from dex_connectors.sdk.projectconfig import load_from_environment
+
+from dex_connectors.docusign import GetEnvelopeInput, new_project_connection
+
+from .flow import CONNECTION_NAME, EnvelopeStatusFlow
+
+
+async def start_envelope_status(flow_id: str, input_file: Path) -> str:
+    """Decode one safe envelope ID and start the registered Dex Flow."""
+    encoded_input = input_file.read_bytes()
+    if len(encoded_input) > 4096:
+        raise ValueError("envelope status input exceeds 4096 bytes")
+    value = (
+        dex.CodecRegistry()
+        .resolve(GetEnvelopeInput)
+        .decode(dex.Value(dex.WireKind.JSON, encoded_input.decode("utf-8")))
+    )
+    project = await load_from_environment()
+    connection = new_project_connection(project, CONNECTION_NAME)
+    try:
+        flow = EnvelopeStatusFlow(connection)
+        registry = dex.Registry([flow], allow_async_handlers=True)
+        with tempfile.TemporaryDirectory(prefix="docusign-python-start-") as directory:
+            cache = dex.open_blob_cache(dex.BlobCacheConfig(directory, 1 << 24))
+            try:
+                address = os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")
+                async with dex.AsyncClient(
+                    registry, cache, dex.ClientOptions(server_address=address)
+                ) as client:
+                    return await client.start_flow(flow, flow_id, value)
+            finally:
+                cache.close()
+    finally:
+        await connection.aclose()
+        await project.close()
+
+
+def main() -> None:
+    """Accept a Flow ID and a JSON input path from the command line."""
+    parser = argparse.ArgumentParser(description="Read a DocuSign envelope in Dex")
+    parser.add_argument("flow_id")
+    parser.add_argument("input_file", type=Path)
+    arguments = parser.parse_args()
+    print(asyncio.run(start_envelope_status(arguments.flow_id, arguments.input_file)))
+
+
+if __name__ == "__main__":
+    main()

dex_connector_docusign-0.1.0/examples/envelope_status/worker.py

@@ -0,0 +1,28 @@
+# Copyright (c) 2026 Super Durable
+# SPDX-License-Identifier: MIT
+"""Run the DocuSign example with an asynchronous Dex Worker."""
+
+import os
+import tempfile
+from pathlib import Path
+
+import dex
+
+from .flow import EnvelopeStatusFlow
+
+
+async def run_worker(flow: EnvelopeStatusFlow) -> None:
+    """Serve the registered example Flow until shutdown."""
+    registry = dex.Registry([flow], allow_async_handlers=True)
+    cache_directory = os.environ.get(
+        "DEX_BLOB_CACHE_DIR", str(Path(tempfile.gettempdir()) / "dex-docusign-python-blobs")
+    )
+    cache = dex.open_blob_cache(dex.BlobCacheConfig(cache_directory, 1 << 30))
+    try:
+        options = dex.WorkerOptions(
+            server_address=os.environ.get("DEX_FLOW_SERVICE_ADDRESS", "localhost:8801")
+        )
+        async with dex.AsyncWorker(registry, cache, options) as worker:
+            await worker.start()
+    finally:
+        cache.close()

dex_connector_docusign-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dex-connector-docusign"
+version = "0.1.0"
+description = "DocuSign eSignature connector for Dex Flows"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = ["dex-connectors-sdk==0.7.0", "dex-python-sdk>=1.28.0", "httpx>=0.27"]
+
+[project.urls]
+Source = "https://github.com/superdurable/dex-connectors-library/tree/main/connectors/docusign/python"
+
+[dependency-groups]
+dev = ["pytest>=8", "pytest-asyncio>=0.24", "mypy>=1.13", "ruff>=0.7", "PyYAML>=6", "types-PyYAML>=6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dex_connectors"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = [".", "src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+python_version = "3.11"
+strict = true
+mypy_path = "src"
+explicit_package_bases = true
+
+[tool.ruff]
+target-version = "py311"
+line-length = 110
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]