keycardai-temporal 0.1.0__tar.gz

keycardai_temporal-0.1.0/.gitignore

@@ -0,0 +1,194 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+.venv-leg
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, uncomment below!
+#.idea/
+
+# VS Code
+.vscode/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Backup files
+*~
+*.bak
+*.backup
+*.old
+*.orig
+
+# Temporary files
+*.tmp
+*.temp
+
+# IDE files
+*.swp
+*.swo
+*~
+
+# Local development
+.local/
+
+# Claude Code
+CLAUDE.md

keycardai_temporal-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.5
+Name: keycardai-temporal
+Version: 0.1.0
+Summary: Temporal integration for Keycard: per-call token minting for activities, with nothing in workflow history
+Project-URL: Homepage, https://github.com/keycardai/python-sdk
+Project-URL: Repository, https://github.com/keycardai/python-sdk
+Project-URL: Documentation, https://docs.keycardai.com
+Project-URL: Issues, https://github.com/keycardai/python-sdk/issues
+Author-email: Keycard <support@keycard.ai>
+License: MIT
+Keywords: activities,authentication,keycard,oauth,temporal,token-exchange,workflows
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: keycardai-oauth>=0.26.0
+Requires-Dist: temporalio>=1.32.0
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=1.1.0; extra == 'test'
+Requires-Dist: pytest>=8.4.1; extra == 'test'
+Description-Content-Type: text/markdown
+
+# keycardai-temporal
+
+Per-call Keycard token minting for Temporal Python workers, built on `keycardai-oauth`.
+
+An activity declares the resource it needs with `@grant(resource)`, the worker's `KeycardInterceptor` mints a fresh token for every activity execution, and `access()` returns it inside the activity. Nothing is written to workflow history.
+
+```bash
+pip install keycardai-temporal
+```
+
+## Quick start
+
+```python
+from datetime import timedelta
+
+from temporalio import activity, workflow
+from temporalio.worker import Worker
+
+from keycardai.temporal import KeycardInterceptor, access, grant
+
+LEDGER = "https://ledger.example.com"
+
+
+@grant(LEDGER)
+@activity.defn
+async def post_entry(order_id: str) -> str:
+    token = access().access_token  # fresh for this execution only
+    ...  # call the ledger with the token
+    return "posted"
+
+
+@workflow.defn
+class SettlementWorkflow:
+    @workflow.run
+    async def run(self, order_id: str) -> str:
+        return await workflow.execute_activity(
+            post_entry, order_id, start_to_close_timeout=timedelta(seconds=30)
+        )
+
+
+async def main(client):
+    interceptor = KeycardInterceptor("https://<zone-id>.keycard.cloud")
+    async with Worker(
+        client,
+        task_queue="settlement",
+        workflows=[SettlementWorkflow],
+        activities=[post_entry],
+        interceptors=[interceptor],
+    ):
+        ...
+```
+
+### Credential discovery
+
+With no `credential` argument, `KeycardInterceptor` calls `keycardai.oauth.server.discover_credential()`, the SDK-wide environment convention:
+
+- `KEYCARD_CLIENT_ID` and `KEYCARD_CLIENT_SECRET` together build a `ClientSecret`.
+- A token file named by `KEYCARD_EKS_WORKLOAD_IDENTITY_TOKEN_FILE`, `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE`, `AWS_WEB_IDENTITY_TOKEN_FILE`, or `AZURE_FEDERATED_TOKEN_FILE` builds a `WorkloadIdentity`.
+- `KEYCARD_APPLICATION_CREDENTIAL_TYPE` (`client_secret` or `workload_identity`; `eks_workload_identity` is a legacy alias) names the type to use, and wins over everything else in the environment.
+
+When the environment can build more than one credential and the type variable does not choose between them, the worker fails at startup with `GrantConfigurationError` instead of guessing. EKS IRSA injects `AWS_WEB_IDENTITY_TOKEN_FILE` into pods automatically, so a worker meant to use a client secret on EKS must set `KEYCARD_APPLICATION_CREDENTIAL_TYPE=client_secret`. Any `keycardai.oauth.server.ApplicationCredential` can also be passed explicitly, which skips discovery entirely.
+
+## Keycard setup
+
+In your Keycard zone, once:
+
+1. Create an application for the worker with a credential (a `ClientSecret`, or any workload identity credential the worker's platform supports).
+2. Create the resource the activities will call. For plain client-credentials issuance, the Zone Provider is enough as its credential provider: nothing exchanges from its tokens.
+3. Add the resource to the application's dependencies. App-only issuance needs the dependency; with no user there is no consent step.
+4. For on-behalf-of activities, one more piece of zone topology: the exchange rule requires the exchanging application to provide the resource the subject token is audienced to, so the worker's application needs a small anchor resource of its own, with user sessions audienced to it.
+
+The resource identifier in `@grant(...)` must match the console registration byte for byte; a trailing character difference reads as a different resource and policy denies it.
+
+## Identity modes
+
+- `@grant(resource)`: the application acts as itself (client credentials). Requires a `ClientSecret` credential.
+- `@grant(resource, subject_from=...)`: the application acts on behalf of a user. The activity input carries an identity reference (a user id, never a token). The interceptor's `subject_token_provider`, an application-supplied session lookup, returns that user's current session token, and an RFC 8693 exchange turns it into a token for the resource.
+- `@grant(resource, subject_from=..., impersonate=True)`: impersonation, for workflows that outlive the user's session. The located value is a stable user identifier (email or oid) sent directly to the zone, which mints a short-lived substitute-user token. No session lookup runs and no `subject_token_provider` is needed. This is a different trust model from delegation: the worker asserts who the user is, and zone policy is the control. It requires a confidential client, application consent set to implicit, the resource declared as a dependency of the application, a prior delegated grant established by the user for the resource, and zone policy that explicitly permits the application to impersonate (forbidden by default). Prefer live delegation whenever the user's session is still expected to exist.
+
+### Locating the identity reference
+
+```python
+from typing import Annotated
+from dataclasses import dataclass
+
+from keycardai.temporal import Subject, grant
+
+
+@dataclass
+class Order:
+    order_id: str
+    approver_id: Annotated[str, Subject()]
+
+
+@grant(LEDGER)                                       # Subject() marker, validated at decoration time
+async def approve(order: Order) -> None: ...
+
+@grant(LEDGER, subject_from="approver_id")           # parameter name ...
+async def approve(order_id: str, approver_id: str) -> None: ...
+
+@grant(LEDGER, subject_from="order.approver_id")     # ... or a dotted path into one
+async def approve(order: dict) -> None: ...
+
+@grant(LEDGER, subject_from=lambda order: order["approver_id"])  # sync callable escape hatch
+async def approve(order: dict) -> None: ...
+```
+
+Use one strategy per activity: a `Subject()` marker together with `subject_from` is rejected at decoration time.
+
+The worker supplies the session lookup:
+
+```python
+async def session_token_for(approver_id: str) -> str:
+    return await sessions.current_token(approver_id)
+
+interceptor = KeycardInterceptor(
+    "https://<zone-id>.keycard.cloud",
+    subject_token_provider=session_token_for,
+)
+```
+
+## Design notes
+
+- Tokens never touch durable state. Workflow history is replayable and permanent, so unlike header-based context-propagation interceptors, nothing is written to activity headers, arguments, or return values. The token exists only inside one execution's context. This is also why on-behalf-of activities receive an identity reference instead of a token: the session lookup and exchange happen at the edge, inside the execution, so a session revoked mid-workflow is never replayed from state.
+- A mint failure raises before the activity body runs, and there is no fallback path. Tokens live in the SDK's shared `AccessContext` (the same container `keycardai-mcp` uses), but where that idiom is non-throwing, the interceptor converts recorded errors into raises on purpose: in Temporal, raising is the error channel.
+- Transient mint failures are retryable; permanent denials are not. Network failures and unclassified errors let the activity retry policy govern what happens next, while `access_denied`, `insufficient_authorization`, and `invalid_client` raise `ApplicationError(type="KeycardAccessDenied", non_retryable=True)` immediately. Misdeclarations surface as `GrantConfigurationError`, retryable by default so a worker redeploy with the fix lets the next retry succeed; list `"GrantConfigurationError"` in the retry policy's `non_retryable_error_types` to give up sooner.
+- No token caching, per Keycard's credential rules; per-call mint is the contract. One OAuth client is created per worker and reused; only the tokens are fresh.
+- The package wraps its own `keycardai` imports in `workflow.unsafe.imports_passed_through()`, the idiom from Temporal's sentry sample, so consumers import it normally even in files that define workflows.
+- Works with async activities and with sync activities on the thread-pool executor (the Temporal SDK copies contextvars into the thread). Sync activities on a process-pool executor are not supported because contextvars do not cross processes.
+
+## Tests
+
+```bash
+cd packages/temporal && uv run --extra test pytest tests/ -v
+```
+
+`tests/test_interceptor.py` drives the interceptor chain directly with the OAuth client stubbed. `tests/test_history_hygiene.py` runs a real workflow against a local Temporal dev server (downloaded by `temporalio` on first use), then scans the recorded history, including base64-decoded payloads, and asserts the minted token appears nowhere. Neither needs a Keycard zone.

keycardai_temporal-0.1.0/README.md

@@ -0,0 +1,137 @@
+# keycardai-temporal
+
+Per-call Keycard token minting for Temporal Python workers, built on `keycardai-oauth`.
+
+An activity declares the resource it needs with `@grant(resource)`, the worker's `KeycardInterceptor` mints a fresh token for every activity execution, and `access()` returns it inside the activity. Nothing is written to workflow history.
+
+```bash
+pip install keycardai-temporal
+```
+
+## Quick start
+
+```python
+from datetime import timedelta
+
+from temporalio import activity, workflow
+from temporalio.worker import Worker
+
+from keycardai.temporal import KeycardInterceptor, access, grant
+
+LEDGER = "https://ledger.example.com"
+
+
+@grant(LEDGER)
+@activity.defn
+async def post_entry(order_id: str) -> str:
+    token = access().access_token  # fresh for this execution only
+    ...  # call the ledger with the token
+    return "posted"
+
+
+@workflow.defn
+class SettlementWorkflow:
+    @workflow.run
+    async def run(self, order_id: str) -> str:
+        return await workflow.execute_activity(
+            post_entry, order_id, start_to_close_timeout=timedelta(seconds=30)
+        )
+
+
+async def main(client):
+    interceptor = KeycardInterceptor("https://<zone-id>.keycard.cloud")
+    async with Worker(
+        client,
+        task_queue="settlement",
+        workflows=[SettlementWorkflow],
+        activities=[post_entry],
+        interceptors=[interceptor],
+    ):
+        ...
+```
+
+### Credential discovery
+
+With no `credential` argument, `KeycardInterceptor` calls `keycardai.oauth.server.discover_credential()`, the SDK-wide environment convention:
+
+- `KEYCARD_CLIENT_ID` and `KEYCARD_CLIENT_SECRET` together build a `ClientSecret`.
+- A token file named by `KEYCARD_EKS_WORKLOAD_IDENTITY_TOKEN_FILE`, `AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE`, `AWS_WEB_IDENTITY_TOKEN_FILE`, or `AZURE_FEDERATED_TOKEN_FILE` builds a `WorkloadIdentity`.
+- `KEYCARD_APPLICATION_CREDENTIAL_TYPE` (`client_secret` or `workload_identity`; `eks_workload_identity` is a legacy alias) names the type to use, and wins over everything else in the environment.
+
+When the environment can build more than one credential and the type variable does not choose between them, the worker fails at startup with `GrantConfigurationError` instead of guessing. EKS IRSA injects `AWS_WEB_IDENTITY_TOKEN_FILE` into pods automatically, so a worker meant to use a client secret on EKS must set `KEYCARD_APPLICATION_CREDENTIAL_TYPE=client_secret`. Any `keycardai.oauth.server.ApplicationCredential` can also be passed explicitly, which skips discovery entirely.
+
+## Keycard setup
+
+In your Keycard zone, once:
+
+1. Create an application for the worker with a credential (a `ClientSecret`, or any workload identity credential the worker's platform supports).
+2. Create the resource the activities will call. For plain client-credentials issuance, the Zone Provider is enough as its credential provider: nothing exchanges from its tokens.
+3. Add the resource to the application's dependencies. App-only issuance needs the dependency; with no user there is no consent step.
+4. For on-behalf-of activities, one more piece of zone topology: the exchange rule requires the exchanging application to provide the resource the subject token is audienced to, so the worker's application needs a small anchor resource of its own, with user sessions audienced to it.
+
+The resource identifier in `@grant(...)` must match the console registration byte for byte; a trailing character difference reads as a different resource and policy denies it.
+
+## Identity modes
+
+- `@grant(resource)`: the application acts as itself (client credentials). Requires a `ClientSecret` credential.
+- `@grant(resource, subject_from=...)`: the application acts on behalf of a user. The activity input carries an identity reference (a user id, never a token). The interceptor's `subject_token_provider`, an application-supplied session lookup, returns that user's current session token, and an RFC 8693 exchange turns it into a token for the resource.
+- `@grant(resource, subject_from=..., impersonate=True)`: impersonation, for workflows that outlive the user's session. The located value is a stable user identifier (email or oid) sent directly to the zone, which mints a short-lived substitute-user token. No session lookup runs and no `subject_token_provider` is needed. This is a different trust model from delegation: the worker asserts who the user is, and zone policy is the control. It requires a confidential client, application consent set to implicit, the resource declared as a dependency of the application, a prior delegated grant established by the user for the resource, and zone policy that explicitly permits the application to impersonate (forbidden by default). Prefer live delegation whenever the user's session is still expected to exist.
+
+### Locating the identity reference
+
+```python
+from typing import Annotated
+from dataclasses import dataclass
+
+from keycardai.temporal import Subject, grant
+
+
+@dataclass
+class Order:
+    order_id: str
+    approver_id: Annotated[str, Subject()]
+
+
+@grant(LEDGER)                                       # Subject() marker, validated at decoration time
+async def approve(order: Order) -> None: ...
+
+@grant(LEDGER, subject_from="approver_id")           # parameter name ...
+async def approve(order_id: str, approver_id: str) -> None: ...
+
+@grant(LEDGER, subject_from="order.approver_id")     # ... or a dotted path into one
+async def approve(order: dict) -> None: ...
+
+@grant(LEDGER, subject_from=lambda order: order["approver_id"])  # sync callable escape hatch
+async def approve(order: dict) -> None: ...
+```
+
+Use one strategy per activity: a `Subject()` marker together with `subject_from` is rejected at decoration time.
+
+The worker supplies the session lookup:
+
+```python
+async def session_token_for(approver_id: str) -> str:
+    return await sessions.current_token(approver_id)
+
+interceptor = KeycardInterceptor(
+    "https://<zone-id>.keycard.cloud",
+    subject_token_provider=session_token_for,
+)
+```
+
+## Design notes
+
+- Tokens never touch durable state. Workflow history is replayable and permanent, so unlike header-based context-propagation interceptors, nothing is written to activity headers, arguments, or return values. The token exists only inside one execution's context. This is also why on-behalf-of activities receive an identity reference instead of a token: the session lookup and exchange happen at the edge, inside the execution, so a session revoked mid-workflow is never replayed from state.
+- A mint failure raises before the activity body runs, and there is no fallback path. Tokens live in the SDK's shared `AccessContext` (the same container `keycardai-mcp` uses), but where that idiom is non-throwing, the interceptor converts recorded errors into raises on purpose: in Temporal, raising is the error channel.
+- Transient mint failures are retryable; permanent denials are not. Network failures and unclassified errors let the activity retry policy govern what happens next, while `access_denied`, `insufficient_authorization`, and `invalid_client` raise `ApplicationError(type="KeycardAccessDenied", non_retryable=True)` immediately. Misdeclarations surface as `GrantConfigurationError`, retryable by default so a worker redeploy with the fix lets the next retry succeed; list `"GrantConfigurationError"` in the retry policy's `non_retryable_error_types` to give up sooner.
+- No token caching, per Keycard's credential rules; per-call mint is the contract. One OAuth client is created per worker and reused; only the tokens are fresh.
+- The package wraps its own `keycardai` imports in `workflow.unsafe.imports_passed_through()`, the idiom from Temporal's sentry sample, so consumers import it normally even in files that define workflows.
+- Works with async activities and with sync activities on the thread-pool executor (the Temporal SDK copies contextvars into the thread). Sync activities on a process-pool executor are not supported because contextvars do not cross processes.
+
+## Tests
+
+```bash
+cd packages/temporal && uv run --extra test pytest tests/ -v
+```
+
+`tests/test_interceptor.py` drives the interceptor chain directly with the OAuth client stubbed. `tests/test_history_hygiene.py` runs a real workflow against a local Temporal dev server (downloaded by `temporalio` on first use), then scans the recorded history, including base64-decoded payloads, and asserts the minted token appears nowhere. Neither needs a Keycard zone.

keycardai_temporal-0.1.0/pyproject.toml

@@ -0,0 +1,141 @@
+[project]
+name = "keycardai-temporal"
+dynamic = ["version"]
+description = "Temporal integration for Keycard: per-call token minting for activities, with nothing in workflow history"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Keycard", email = "support@keycard.ai" }]
+dependencies = [
+    "keycardai-oauth>=0.26.0",
+    "temporalio>=1.32.0",
+]
+keywords = ["temporal", "workflows", "activities", "oauth", "token-exchange", "authentication", "keycard"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Security",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/keycardai/python-sdk"
+Repository = "https://github.com/keycardai/python-sdk"
+Documentation = "https://docs.keycardai.com"
+Issues = "https://github.com/keycardai/python-sdk/issues"
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+pattern = "(?P<base>\\d+\\.\\d+\\.\\d+)-keycardai-temporal"
+style = "pep440"
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/keycardai"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "B",  # flake8-bugbear
+    "C4", # flake8-comprehensions
+    "UP", # pyupgrade
+]
+ignore = [
+    "E501",  # line too long, we'll handle case by case
+]
+isort = { combine-as-imports = true, known-first-party = ["keycardai"] }
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["T20"]
+
+[tool.mypy]
+strict = true
+disallow_incomplete_defs = false
+disallow_untyped_defs = false
+disallow_untyped_calls = false
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+
+[tool.coverage.run]
+source = ["tests", "src/keycardai"]
+
+[tool.coverage.report]
+show_missing = true
+exclude_also = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "@abc.abstractmethod",
+    "raise NotImplementedError",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra -q"
+asyncio_mode = "auto"
+
+[tool.commitizen]
+name = "cz_customize"
+version = "0.1.0"
+tag_format = "${version}-keycardai-temporal"
+ignored_tag_formats = ["${version}-*"]
+update_changelog_on_bump = true
+bump_message = "bump: keycardai-temporal $current_version → $new_version"
+major_version_zero = true
+
+[tool.commitizen.customize]
+# Scoped bump detection: without bump_pattern/bump_map commitizen falls back to
+# its default classifier, which matches any `feat(...)!:` regardless of scope.
+changelog_pattern = "^(feat|fix|refactor|perf|test|revert)\\(keycardai-temporal\\)(!)?:"
+bump_pattern = "^((?:feat|fix|refactor|perf|revert|BREAKING[\\- ]CHANGE)\\(keycardai-temporal\\)!?):"
+
+[tool.commitizen.customize.bump_map]
+"^.+\\(keycardai-temporal\\)!$" = "MAJOR"
+"^BREAKING[\\- ]CHANGE" = "MAJOR"
+"^feat" = "MINOR"
+"^fix" = "PATCH"
+"^refactor" = "PATCH"
+"^perf" = "PATCH"
+"^revert" = "PATCH"
+
+[tool.commitizen.customize.bump_map_major_version_zero]
+"^.+\\(keycardai-temporal\\)!$" = "MINOR"
+"^BREAKING[\\- ]CHANGE" = "MINOR"
+"^feat" = "MINOR"
+"^fix" = "PATCH"
+"^refactor" = "PATCH"
+"^perf" = "PATCH"
+"^revert" = "PATCH"