mistralai-workflows-cli 1.2.1__tar.gz → 1.2.3__tar.gz

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/.gitignore

@@ -219,6 +219,9 @@ jobs/run/checkpoints/test/consolidated/params.json
 
 # Cursor plans folder
 .cursor/plans/
+
+# Agent plans (scratch planning docs)
+.agents/plans/
 tsconfig.tsbuildinfo
 
 .vscode-test/

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/Makefile

@@ -42,6 +42,7 @@ integration-test:
 	$(MAKE) _test-start-examples
 	$(MAKE) _test-execute-help
 	$(MAKE) _test-execute-bad-json
+	$(MAKE) _test-make-check
 	$(MAKE) _test-wheel-contents
 	@echo ""
 	@echo "All integration tests passed."
@@ -124,3 +125,8 @@ _test-wheel-contents:
 		| grep -q "entrypoints/worker.py" \
 		&& echo "OK: wheel contains entrypoints package" \
 		|| (echo "FAIL: wheel is missing the entrypoints package" && exit 1)
+
+_test-make-check:
+	@echo "--- test: 'make check' (ruff, mypy, workflow lint) passes on the generated project"
+	cd $(GENERATED_PROJECT) && $(MAKE) check
+	@echo "OK: make check passes on the generated project"

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mistralai-workflows-cli
-Version: 1.2.1
+Version: 1.2.3
 Summary: CLI to bootstrap Mistral Workflows projects
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/pyproject.toml

@@ -32,8 +32,7 @@ packages = ["src/mistral_workflows_cli"]
 
 [tool.ruff]
 line-length = 120
-# The copier template is project data, not part of the CLI's own source.
-extend-exclude = ["src/mistral_workflows_cli/_template"]
+extend-exclude = ["src/mistral_workflows_cli/_template/template/src/examples/code_modernization/sample_data/legacy_repo"]
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP"]

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/SKILL.md

@@ -73,10 +73,11 @@ The documentation is organized into several categories:
 - **[Payload Encoding](references/guides/payload-encoding.mdx)**: Payload offloading, AES-GCM encryption, key rotation
 - **[Observability](references/guides/observability.mdx)**: OpenTelemetry traces, trace sampling
 - **[Durable Agents](references/guides/durable-agents.mdx)**: Agent, Runner, RemoteSession/LocalSession, MCP, multi-agent handoffs
+- **[Connectors](references/guides/connectors.mdx)**: Call third-party tools (GitHub, Notion, Slack, ...) from a workflow or give them to an agent, without holding the service's credentials
 - **[Conversational Workflows](references/guides/assist-workflows.mdx)**: InteractiveWorkflow, HITL, ChatInput/FormInput, Canvas editing, Rich UI components, Tool UI states
 - **[Local Execution](references/guides/local-execution.mdx)**: No-infra dev mode with Pydantic model params
-- **[Limitations](references/guides/limitations.mdx)**: System constraints and limits
-- **[Workflows Plugins](references/guides/workflows-plugins.mdx)**: Mistral AI plugin, Webhook plugin, Nuage plugin, custom plugins
+- **[Limitations](references/guides/limitations.mdx)**: System constraints, determinism rules, sandbox import restrictions (module-level non-deterministic imports + `imports_passed_through`), I/O and heavy work belongs in activities, execution-history limits
+- **[Workflows Plugins](references/guides/workflows-plugins.mdx)**: Mistral AI plugin (calling chat / structured-output / embeddings / OCR models), Webhook plugin, Nuage plugin, custom plugins
 - **[Deployment Patterns](references/guides/_deployment-patterns.mdx)**: Best practices for deploying workflows
 - **[Migration v2 to v3](references/guides/migration-v2-to-v3.mdx)**: Breaking changes and upgrade steps from SDK v2 through v3.4.0
 
@@ -100,6 +101,16 @@ python .agents/skills/workflows/scripts/test_workflow.py <workflow_file> --input
 
 If a workflow is known to be long-running (e.g. multi-step agent, large data processing), increase timeouts proportionally — but start short and only raise them when you see legitimate timeout failures, not preemptively.
 
+**Lint & check** — validate your code before running it. Three checks are available:
+- `make lint` — Ruff: style, imports, and common errors (`make format` auto-fixes most)
+- `make typecheck` — mypy static type checking
+- `make lint-workflows` — Semgrep workflow rules: determinism violations, I/O outside activities, missing return-type annotations, unsafe imports (advisory — reports but does not block)
+
+Run all three at once after writing or editing a workflow, and address any findings:
+```bash
+make check
+```
+
 ### Internal References
 
 These are additional patterns and utilities not covered in the official docs:
@@ -121,6 +132,7 @@ Use this skill when you need to:
 7. **Build conversational workflows**: Create interactive workflows with HITL, forms, canvas, and rich UI
 8. **Ensure fault tolerance**: Implement systems that can recover from failures automatically
 9. **Stream events**: Real-time token streaming and progress updates via NATS
+10. **Integrate external services**: Call GitHub, Notion, Slack, and other connectors with platform-managed credentials
 
 ## Key Features
 
@@ -135,5 +147,5 @@ Use this skill when you need to:
 - **Large payload handling**: OffloadableField with S3/Azure/GCS blob storage
 - **Conversational workflows**: Interactive workflows with Vibe integration, forms, canvas, and rich UI components
 - **Durable agents**: AI agents with MCP support, multi-agent handoffs, and persistent state
+- **Connectors**: Call external services with platform-managed credentials avoiding secrets in the workflow code
 - **Scalability**: Designed to handle complex, distributed applications
-

mistralai_workflows_cli-1.2.3/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/references/guides/connectors.mdx

@@ -0,0 +1,178 @@
+---
+id: connectors
+title: Connectors
+sidebar_position: 8
+---
+
+# Connectors in Workflows
+
+Connectors let workflows call external services (GitHub, Notion, Slack, ...) using credentials managed by the Mistral Connectors platform. The workflow **declares** which connectors it needs; the platform resolves credentials and drives any OAuth flow automatically. The same code works whether the connector uses a bearer/PAT token or OAuth2. **You never put secrets in workflow code**.
+
+Connectors ship in the Mistral plugin:
+
+```bash
+uv add 'mistralai-workflows[mistralai]'
+```
+
+### Discovering configured connectors
+
+The `name` you pass to `connector(...)` must match a connector already configured for the workspace, don't guess them ever! To see the configured connectors and their exact names, run:
+
+```bash
+uv run python -c "from dotenv import load_dotenv; load_dotenv(); import os; from mistralai.client import Mistral; print(*[c.name for c in Mistral(api_key=os.environ['MISTRAL_API_KEY']).beta.connectors.list().items], sep='\n')"
+```
+
+For a connector's tools, use `list_tools` (returns a plain list, not `.items`) and don't guess them even if you think you know how they must be called!:
+
+```bash
+uv run python -c "from dotenv import load_dotenv; load_dotenv(); import os; from mistralai.client import Mistral; print(*[t.name for t in Mistral(api_key=os.environ['MISTRAL_API_KEY']).beta.connectors.list_tools(connector_id_or_name='github_app')], sep='\n')"
+```
+
+Each tool also has `.jsonschema` for its `arguments` (add `t.jsonschema` to the print when you need it).
+(You only need these calls to figure out how to write the code. Don't put these snippets in the workflow itself.)
+
+## Declaring connectors in a workflow
+
+Three pieces wire a connector in:
+
+1. `connector("name")` — declares a **connector slot**.
+2. `@uses_connectors(...)` — attaches slots to the workflow class; apply it **after** `@workflow.define` (on the line below).
+3. `Depends(slot)` — injects a `ToolCallClient` into an activity.
+
+```python
+import pydantic
+import mistralai.workflows as workflows
+from mistralai.workflows import Depends
+from mistralai.workflows.plugins.mistralai.connectors import (
+    ToolCallClient,
+    connector,
+    uses_connectors,
+)
+
+github = connector("github_app")
+
+
+class CreateIssueInput(pydantic.BaseModel):
+    owner: str
+    repo: str
+    title: str
+    body: str
+
+
+@workflows.activity(name="create-github-issue")
+async def create_github_issue(
+    owner: str,
+    repo: str,
+    title: str,
+    body: str,
+    client: ToolCallClient = Depends(github),
+) -> None:
+    await client.call_tool(
+        tool_name="issue_write",
+        arguments={
+            "method": "create",
+            "owner": owner,
+            "repo": repo,
+            "title": title,
+            "body": body,
+        },
+    )
+
+
+@workflows.workflow.define(name="github-issue-creator")
+@uses_connectors(github)
+class GitHubIssueCreatorWorkflow:
+    @workflows.workflow.entrypoint
+    async def run(self, prompt: CreateIssueInput) -> None:
+        await create_github_issue(prompt.owner, prompt.repo, prompt.title, prompt.body)
+```
+
+Watch out for:
+
+- **Import path** is `mistralai.workflows.plugins.mistralai.connectors` (repeated `mistralai`), not `...plugins.connectors`.
+- **`@uses_connectors` is required** and sits **below** `@workflow.define`. Without it, credentials are never resolved and `call_tool` fails.
+- A `ToolCallClient` only works **inside an activity** (it resolves credentials from the workflow context at call time). A failed call raises `ConnectorToolCallError` (non-retryable).
+- **Tool names and argument schemas are connector-specific** (e.g. GitHub's `issue_write`, Notion's `notion-create-pages`) and aren't inferable from the SDK types. Discover them with `client.beta.connectors.list_tools_async(connector_id_or_name=...)` or take them from the task — don't guess.
+- **No special worker setup** — the Mistral plugin auto-registers the connector auth interceptor; run on a normal worker.
+
+### `connector(...)` parameters
+
+| Parameter | Default | Purpose |
+| --- | --- | --- |
+| `name` (positional) | — | Must match a connector configured for the workspace; discover via `client.beta.connectors.list_async()`. |
+| `auto_auth` | `True` | Run the OAuth preflight before the workflow starts. |
+| `credentials_name` | `None` | Pin a specific named credential set; otherwise the user's default is used. |
+| `allow_mcp_ui` | `False` | Surface an MCP tool's `_meta.ui.resourceUri` as a side app in Vibe after a matching tool call (fire-and-forget — the workflow doesn't wait for or consume the result). |
+
+## Acting as the user (on-behalf-of)
+
+A connector call runs as one of two identities:
+
+- **The triggering user** — set `on_behalf_of=True` on `@workflow.define`, and the connector uses the credentials *that user* authorized (their GitHub, their Notion, ...).
+- **The worker** (default) — the connector uses the worker's own stored credentials: one shared service identity for every run.
+
+```python
+@workflows.workflow.define(name="github-issue-creator", on_behalf_of=True)
+@uses_connectors(github)
+class GitHubIssueCreatorWorkflow:
+    ...
+```
+
+Fall back to worker credentials (omit `on_behalf_of`) when there's no triggering user or you deliberately want one shared identity. Caveats (platform-enforced):
+
+- **Needs a triggering user.** Starting an `on_behalf_of=True` workflow without a user session is rejected (`403 "On-behalf-of workflows require user identity"`). For the same reason it **can't be combined with `schedules`** — the SDK raises at definition time, since a scheduled run has no triggering user.
+- **Restricted to Mistral-internal orgs.** Registering an `on_behalf_of=True` workflow returns `403 "on_behalf workflows are currently restricted to Mistral-internal organizations"` unless the org is internal or the `ON_BEHALF_WORKFLOWS_ENABLED` feature flag is enabled.
+
+## Connectors in durable agents
+
+Pass slots to an `Agent` via `connectors=[...]` so it can call connector tools autonomously. Keep `@uses_connectors` on the workflow. See the [Durable Agents](durable-agents.mdx) guide for agent/runner output handling.
+
+```python
+import mistralai.workflows as workflows
+from mistralai.workflows.plugins.mistralai import Agent, Runner
+from mistralai.workflows.plugins.mistralai.connectors import connector, uses_connectors
+
+github = connector("github_app")
+
+
+@workflows.workflow.define(name="github-agent")
+@uses_connectors(github)
+class GitHubAgentWorkflow:
+    @workflows.workflow.entrypoint
+    async def run(self, repo: str) -> str:
+        agent = Agent(
+            name="github-pr-lister",
+            model="mistral-medium-latest",
+            instructions=f"List recent pull requests on {repo}.",
+            connectors=[github],  # connector tools available to the agent
+        )
+        outputs = await Runner.run(agent=agent, inputs=f"Summarize PRs on {repo}.")
+        return await extract_text(outputs)
+```
+
+OAuth and credential resolution still happen automatically.
+
+## Running a connector workflow
+
+You usually don't run these by hand, they're triggered from Studio/the UI (which shows the OAuth prompt) or by whatever starts the workflow. To trigger one **from Python** when it may need OAuth, use `execute_with_connector_auth_async` (`mistralai.extra.workflows`): it surfaces the auth URL via an `on_auth_required(state)` callback and resumes automatically once the user authorizes. For plain execution without OAuth, see the [Python SDK](../getting-started/python-sdk.mdx) guide.
+
+## Common errors
+
+| Symptom | Cause / fix |
+| --- | --- |
+| `RuntimeError: No workflow context available` | `ToolCallClient` used outside an activity. Inject via `Depends` and call tools inside an `@activity`. |
+| Credentials never resolve / `call_tool` fails | Missing `@uses_connectors`, or the connector `name` doesn't match a configured connector (check `client.beta.connectors.list_async()`). |
+| `ConnectorAuthTimeout` | OAuth not completed within 10 minutes. Re-run and authorize promptly. |
+| `ConnectorToolCallError` | The connector tool rejected the call — check `tool_name` and the `arguments` schema. |
+| `ImportError` for connectors | Install the extra: `uv add 'mistralai-workflows[mistralai]'`; import from `mistralai.workflows.plugins.mistralai.connectors`. |
+
+## Quick reference
+
+| Symbol | Import from | Use |
+| --- | --- | --- |
+| `connector(name, *, auto_auth, credentials_name, allow_mcp_ui)` | `mistralai.workflows.plugins.mistralai.connectors` | Declare a connector slot. |
+| `uses_connectors(*slots)` | same | Class decorator; attach slots (after `@workflow.define`). |
+| `ToolCallClient` / `.call_tool(tool_name, arguments)` | same | Call connector tools from an activity (inject via `Depends`). |
+| `Agent(..., connectors=[...])` | `mistralai.workflows.plugins.mistralai` | Give a durable agent connector tools. |
+| `execute_with_connector_auth_async(...)` | `mistralai.extra.workflows` | Run a connector workflow from Python, handling OAuth (trigger-side, not needed to build a workflow). |
+| `client.beta.connectors.list_async()` / `list_tools_async(connector_id_or_name=)` | `mistralai` client | Discover configured connectors and their tool names/schemas. |

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/references/guides/limitations.mdx

@@ -144,6 +144,17 @@ if os.getenv("ENV") == "prod":
 
 must be performed in activities. While activities themselves can produce different outputs for the same inputs (as they might contain non-deterministic operations), the workflow code must behave deterministically based on the activity results it receives.
 
+### Imports must be deterministic too
+
+The sandbox also validates **imports**. A module-level `import` of a non-deterministic library (`httpx`, `requests`, `aiohttp`, the raw `mistralai` client, etc.) in a workflow file won't work in the sandbox — the worker rejects it while validating the workflow at startup, so the workflow never becomes runnable. Keep such imports **inside the activity** that uses them, or — when a top-level import is unavoidable (e.g. shared type hints) — wrap it so the sandbox lets it through:
+
+```python
+with workflows.workflow.unsafe.imports_passed_through():
+    import httpx
+```
+
+Only pass through imports you know are side-effect-free (no import-time I/O or global-state mutation).
+
 ### Maximum Execution History
 
 The execution history for each workflow is capped at 51,200 events or 50MB per workflow execution. This is a hard limit of the durable execution engine. In order to avoid hitting this limit, we recommend using `workflows.execute_activities_in_parallel`, that allows you to execute large amounts of activities in parallel, while having the lowest footprint on the execution history. [Learn more about concurrency patterns](concurrency).

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/references/guides/rate-limiting.mdx

@@ -28,7 +28,8 @@ When **a key is provided**, multiple different activities that use the same key
 
 ```python
 import mistralai.workflows as workflows
-from mistralai import Mistral, Messages
+from mistralai.client import Mistral
+from mistralai.client.models import ChatCompletionRequestMessage
 from mistralai.workflows import Depends
 from pydantic import BaseModel
 
@@ -41,7 +42,7 @@ def get_mistral_client() -> Mistral:
 
 class CompletionParams(BaseModel):
     model: str
-    messages: Messages
+    messages: list[ChatCompletionRequestMessage]
 
 @workflows.activity(rate_limit=workflows.RateLimit(time_window_in_sec=1, max_calls=100))
 async def generate_chat_response(

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.3}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/references/guides/workflows-plugins.mdx

@@ -78,6 +78,72 @@ class SummarizeWorkflow:
         return result.choices[0].message.content
 ```
 
+**Example — structured output:** to get a validated Pydantic object back instead of a string, define a model and build the same `ChatCompletionRequest` as above, then swap the final call for `chat_parse_to_model`:
+
+```python
+from pydantic import BaseModel
+from mistralai.workflows.plugins.mistralai import chat_parse_to_model
+
+class Sentiment(BaseModel):
+    label: str
+    score: float
+
+# inside the entrypoint, with `request` built as in the chat example above:
+sentiment = await chat_parse_to_model(Sentiment, request)
+```
+
+For the raw response instead of a parsed model, call `mistralai_chat_parse(request, response_format)` directly.
+
+**Example — embeddings** (call from inside an entrypoint or activity):
+
+```python
+from mistralai.workflows.plugins.mistralai import (
+    MistralEmbeddingsParams,
+    mistralai_embeddings,
+)
+
+response = await mistralai_embeddings(
+    MistralEmbeddingsParams(model="mistral-embed", inputs=["first text", "second text"]),
+)
+vectors = [item.embedding for item in response.data]
+```
+
+**Example — OCR** extracts text from a document or image URL:
+
+```python
+from mistralai.client.models import DocumentURLChunk
+from mistralai.workflows.plugins.mistralai import OCRRequest, mistralai_ocr
+
+result = await mistralai_ocr(
+    OCRRequest(
+        model="mistral-ocr-latest",
+        document=DocumentURLChunk(document_url="https://example.com/invoice.pdf"),
+    ),
+)
+pages_markdown = [page.markdown for page in result.pages]
+```
+
+**Raw client (when a plugin activity isn't enough):** call the Mistral API directly from inside an activity. Import the client from `mistralai.client` — `mistralai` is a namespace package, so `from mistralai import Mistral` does **not** work — and keep that import inside the activity function so the workflow sandbox doesn't reject it:
+
+```python
+import os
+from mistralai.workflows import activity
+
+@activity()
+async def summarize(text: str) -> str:
+    # Import inside the activity so the workflow sandbox doesn't reject it.
+    from mistralai.client import Mistral  # NOT `from mistralai import Mistral`
+
+    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
+    resp = await client.chat.complete_async(
+        model="mistral-small-latest",
+        messages=[{"role": "user", "content": text}],
+    )
+    return resp.choices[0].message.content
+```
+
+Model calls and other I/O must run inside an activity, never in the workflow body; see [Limitations](./limitations) for the determinism and import rules.
+
 For full documentation on `Agent`, `Runner`, sessions, MCP, and multi-agent handoffs, see the [Durable Agents guide](./durable-agents).
 
 ### Webhook Plugin

mistralai_workflows_cli-1.2.3/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/scripts/linting/rules/determinism.yaml

@@ -0,0 +1,217 @@
+rules:
+  # Workflow code runs inside a determinism sandbox and is replayed on
+  # recovery.  Non-deterministic operations break replay.  These rules
+  # flag non-deterministic stdlib calls inside `@workflow.define` classes
+  # (the workflow classes).  Activities and plain helper classes are exempt.
+
+  - id: no-datetime-now-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: datetime.now(...)
+          - pattern: datetime.datetime.now(...)
+          - pattern: datetime.utcnow(...)
+          - pattern: datetime.datetime.utcnow(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Use `workflow.now()` instead of `datetime.now()` in workflow code.
+      Workflows must be deterministic — `datetime.now()` returns
+      different values on replay, breaking the execution history.
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Replace with `workflow.now()` from `mistralai.workflows`
+
+  - id: no-uuid4-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: uuid.uuid4(...)
+          - pattern: uuid4(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Use `workflow.uuid4()` instead of `uuid.uuid4()` in workflow code.
+      Standard UUID generation is non-deterministic and breaks replay.
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Replace with `workflow.uuid4()` from `mistralai.workflows`
+
+  - id: no-random-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: random.random(...)
+          - pattern: random.randint(...)
+          - pattern: random.choice(...)
+          - pattern: random.shuffle(...)
+          - pattern: random.sample(...)
+          - pattern: random.uniform(...)
+          - pattern: random.randrange(...)
+          - pattern: random.gauss(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Use `workflow.random()` instead of the `random` module in workflow
+      code. Standard random functions are non-deterministic and break
+      replay.
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Replace with `workflow.random()` from `mistralai.workflows`
+
+  - id: no-os-env-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: os.environ
+          - pattern: os.environ[...]
+          - pattern: os.environ.get(...)
+          - pattern: os.getenv(...)
+          - pattern: os.getcwd(...)
+          - pattern: os.listdir(...)
+          - pattern: os.path.exists(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Do not access `os.environ`, `os.getenv()`, `os.getcwd()`, or
+      filesystem functions in workflow code. Environment variables and
+      filesystem state can differ between replays. Read config in an
+      activity and pass it as workflow input, or use dependency injection.
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Move to an activity or use dependency injection (Depends)
+
+  - id: no-time-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: time.time(...)
+          - pattern: time.monotonic(...)
+          - pattern: time.sleep(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Do not use `time.time()`, `time.monotonic()`, or `time.sleep()`
+      in workflow code. Use `workflow.now()` for timestamps and
+      `asyncio.sleep()` for delays (which is durable and survives
+      replays).
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Use `workflow.now()` for time, `asyncio.sleep()` for delays
+
+  - id: no-hashlib-in-workflow
+    patterns:
+      - pattern-either:
+          - pattern: hashlib.sha256(...)
+          - pattern: hashlib.sha512(...)
+          - pattern: hashlib.md5(...)
+          - pattern: hashlib.sha1(...)
+          - pattern: hashlib.new(...)
+          - pattern: hashlib.pbkdf2_hmac(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Cryptographic operations are CPU-intensive and can exceed the
+      2-second limit between activities. Move hashing to an activity:
+        @activity()
+        async def hash_data(data: bytes) -> str:
+            return hashlib.sha256(data).hexdigest()
+    severity: WARNING
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Move cryptographic operations to an activity
+
+  - id: no-global-in-workflow
+    patterns:
+      - pattern: global $VAR
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Do not use `global` in workflow code. Modifying global variables
+      is non-deterministic — the global state may differ between
+      replays. Store state on `self` or pass it through activities.
+    severity: ERROR
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Use `self.field` for workflow state, or pass data via activities
+
+  - id: no-model-validate-in-workflow
+    patterns:
+      - pattern: $MODEL.model_validate(...)
+      - pattern-either:
+          - pattern-inside: |
+              @workflow.define(...)
+              class $CLASS:
+                  ...
+          - pattern-inside: |
+              @workflows.workflow.define(...)
+              class $CLASS:
+                  ...
+    message: >-
+      Pydantic `.model_validate()` can be CPU-intensive on large
+      payloads and may exceed the 2-second limit between activities.
+      Move heavy validation to an activity:
+        @activity()
+        async def validate(data: dict) -> MyModel:
+            return MyModel.model_validate(data)
+    severity: WARNING
+    languages: [python]
+    metadata:
+      category: determinism
+      fix: Move validation to an activity