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

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/.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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mistralai-workflows-cli
-Version: 1.2.1
+Version: 1.2.2
 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.2}/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.2}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/SKILL.md

@@ -73,6 +73,7 @@ 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
@@ -121,6 +122,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 +137,6 @@ 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.2/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.2}/src/mistral_workflows_cli/_template/template/.agents/skills/workflows/scripts/test_workflow.py

@@ -19,7 +19,6 @@ import asyncio
 import importlib.util
 import inspect
 import json
-import os
 import sys
 import traceback
 from pathlib import Path
@@ -66,11 +65,7 @@ def _import_module(file_path: Path) -> Any:
 
 def _find_workflow_classes(module: Any) -> list[type]:
     """Return all @workflow.define classes in *module*."""
-    return [
-        obj
-        for _, obj in inspect.getmembers(module, inspect.isclass)
-        if hasattr(obj, "__workflows_workflow_def")
-    ]
+    return [obj for _, obj in inspect.getmembers(module, inspect.isclass) if hasattr(obj, "__workflows_workflow_def")]
 
 
 def _workflow_name(cls: type) -> str:
@@ -81,9 +76,7 @@ def _is_interactive(cls: type) -> bool:
     return issubclass(cls, workflows.InteractiveWorkflow)
 
 
-def _discover_workflow(
-    workflow_file: Path, name_override: str | None
-) -> tuple[type, str, bool]:
+def _discover_workflow(workflow_file: Path, name_override: str | None) -> tuple[type, str, bool]:
     """Find and select the workflow class.  Returns (cls, name, interactive)."""
     module = _import_module(workflow_file)
     found = _find_workflow_classes(module)
@@ -98,16 +91,13 @@ def _discover_workflow(
         matches = [w for w in found if _workflow_name(w) == name_override]
         if not matches:
             available = ", ".join(_workflow_name(w) for w in found)
-            raise SystemExit(
-                f"Workflow '{name_override}' not found. Available: {available}"
-            )
+            raise SystemExit(f"Workflow '{name_override}' not found. Available: {available}")
         cls = matches[0]
     else:
         if len(found) > 1:
             names = ", ".join(_workflow_name(w) for w in found)
             print(
-                f"Multiple workflows found: {names}. Using the first one. "
-                "Pass --workflow-name to select.",
+                f"Multiple workflows found: {names}. Using the first one. Pass --workflow-name to select.",
                 file=sys.stderr,
             )
         cls = found[0]
@@ -146,9 +136,7 @@ async def _poll_and_submit_interactions(
         input: dict
 
     for i, response_data in enumerate(interactions, 1):
-        task_id = await _wait_for_pending_input(
-            client, execution_id, i, poll_timeout, poll_interval
-        )
+        task_id = await _wait_for_pending_input(client, execution_id, i, poll_timeout, poll_interval)
 
         print(f"  Interaction {i}: submitting {json.dumps(response_data)}")
         try:
@@ -163,8 +151,7 @@ async def _poll_and_submit_interactions(
             )
         except asyncio.TimeoutError:
             print(
-                f"  Interaction {i}: update timed out "
-                "(workflow may have failed to process the input)",
+                f"  Interaction {i}: update timed out (workflow may have failed to process the input)",
                 file=sys.stderr,
             )
             raise
@@ -193,18 +180,13 @@ async def _wait_for_pending_input(
             if pending:
                 task_id = pending[0]["task_id"]
                 label = pending[0].get("label", "")
-                print(
-                    f"  Interaction {index}: pending input found "
-                    f"(task={task_id[:8]}..., label={label!r})"
-                )
+                print(f"  Interaction {index}: pending input found (task={task_id[:8]}..., label={label!r})")
                 return task_id
         except Exception:
             pass
 
         if asyncio.get_event_loop().time() - start > timeout:
-            raise TimeoutError(
-                f"Timeout waiting for pending input #{index} ({timeout}s)"
-            )
+            raise TimeoutError(f"Timeout waiting for pending input #{index} ({timeout}s)")
         await asyncio.sleep(interval)
 
 
@@ -213,9 +195,7 @@ async def _wait_for_pending_input(
 # ---------------------------------------------------------------------------
 
 
-async def _execute_with_retry(
-    client: Any, wf_name: str, input_dict: dict | None, retries: int = 10
-) -> Any:
+async def _execute_with_retry(client: Any, wf_name: str, input_dict: dict | None, retries: int = 10) -> Any:
     """Start the workflow, retrying on registration-propagation errors."""
     for attempt in range(retries):
         try:
@@ -244,23 +224,17 @@ async def _await_result(
     """
     if not (interactive and interactions):
         final = await asyncio.wait_for(
-            client.workflows.wait_for_workflow_completion_async(
-                execution_id, polling_interval=2
-            ),
+            client.workflows.wait_for_workflow_completion_async(execution_id, polling_interval=2),
             timeout=timeout,
         )
         return final.result
 
     # Run interactions and completion polling concurrently.
     interaction_task = asyncio.create_task(
-        _poll_and_submit_interactions(
-            client, execution_id, interactions, poll_timeout=timeout
-        )
+        _poll_and_submit_interactions(client, execution_id, interactions, poll_timeout=timeout)
     )
     completion_task = asyncio.create_task(
-        client.workflows.wait_for_workflow_completion_async(
-            execution_id, polling_interval=2
-        )
+        client.workflows.wait_for_workflow_completion_async(execution_id, polling_interval=2)
     )
 
     done, pending = await asyncio.wait(
@@ -312,9 +286,7 @@ async def run_workflow(
     _ensure_sdk()
 
     # -- discover --
-    workflow_cls, wf_name, interactive = _discover_workflow(
-        workflow_file, workflow_name_override
-    )
+    workflow_cls, wf_name, interactive = _discover_workflow(workflow_file, workflow_name_override)
 
     print(f"Workflow:      {wf_name} ({workflow_cls.__name__})")
     print(f"Interactive:   {interactive}")
@@ -348,25 +320,19 @@ async def run_workflow(
     execution_id: str | None = None
     try:
         # -- execute --
-        execution = await _execute_with_retry(
-            client, wf_name, _build_input(input_data)
-        )
+        execution = await _execute_with_retry(client, wf_name, _build_input(input_data))
         execution_id = execution.execution_id
         print(f"Execution:     {execution_id}")
         print(f"Status:        {execution.status}\n")
 
         # -- wait for result --
-        return await _await_result(
-            client, execution_id, interactions, interactive, timeout_seconds
-        )
+        return await _await_result(client, execution_id, interactions, interactive, timeout_seconds)
 
     except asyncio.TimeoutError:
         if execution_id:
             print(f"\nTerminating execution {execution_id}...", file=sys.stderr)
             try:
-                await client.workflows.executions.terminate_workflow_execution_async(
-                    execution_id=execution_id
-                )
+                await client.workflows.executions.terminate_workflow_execution_async(execution_id=execution_id)
                 print("Execution terminated.", file=sys.stderr)
             except Exception as e:
                 print(f"Failed to terminate: {e}", file=sys.stderr)
@@ -393,27 +359,32 @@ def _parse_args() -> argparse.Namespace:
         epilog=__doc__,
     )
     parser.add_argument(
-        "workflow_file", type=Path,
+        "workflow_file",
+        type=Path,
         help="Path to the Python file containing the workflow.",
     )
     parser.add_argument(
-        "--input", required=True, dest="input_json",
+        "--input",
+        required=True,
+        dest="input_json",
         help="JSON string with the workflow input.",
     )
     parser.add_argument(
-        "--timeout", type=int, default=30,
+        "--timeout",
+        type=int,
+        default=30,
         help="Max seconds before the workflow is killed (default: 30).",
     )
     parser.add_argument(
-        "--workflow-name", default=None,
+        "--workflow-name",
+        default=None,
         help="Workflow name (if the file contains multiple workflows).",
     )
     parser.add_argument(
-        "--interactions", default=None, dest="interactions_json",
-        help=(
-            "JSON array of interaction responses for interactive workflows. "
-            'Example: \'[{"choice": "WFL"}]\''
-        ),
+        "--interactions",
+        default=None,
+        dest="interactions_json",
+        help=('JSON array of interaction responses for interactive workflows. Example: \'[{"choice": "WFL"}]\''),
     )
     return parser.parse_args()
 
@@ -445,6 +416,7 @@ def main() -> None:
     # Load .env if present.
     try:
         from dotenv import load_dotenv
+
         load_dotenv(override=True)
     except ImportError:
         pass

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/src/mistral_workflows_cli/_template/template/src/entrypoints/start.py

@@ -46,9 +46,7 @@ async def main() -> None:
 
     raw_input = raw_input or {}
     if not isinstance(raw_input, dict):
-        raise SystemExit(
-            f"Error: --input must be a JSON object, got {type(raw_input).__name__}"
-        )
+        raise SystemExit(f"Error: --input must be a JSON object, got {type(raw_input).__name__}")
 
     api_key = os.environ.get("MISTRAL_API_KEY", "")
     if not api_key:

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/src/mistral_workflows_cli/_template/template/src/entrypoints/worker.py

@@ -3,12 +3,12 @@
 
 import asyncio
 import importlib
-from dotenv import load_dotenv
-
 import inspect
 import pkgutil
 import sys
 
+from dotenv import load_dotenv
+
 load_dotenv(override=True)
 
 import mistralai.workflows as mistralai_workflows
@@ -22,9 +22,7 @@ def discover_workflows() -> list[type]:
     discovered = []
     package = importlib.import_module("workflows")
 
-    for _, modname, ispkg in pkgutil.iter_modules(
-        package.__path__, prefix="workflows."
-    ):
+    for _, modname, ispkg in pkgutil.iter_modules(package.__path__, prefix="workflows."):
         if ispkg:
             continue
         module = importlib.import_module(modname)

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/src/mistral_workflows_cli/_template/template/src/examples/cargo_release/activities.py

@@ -6,10 +6,9 @@ The workflow body calls these as awaitable activity proxies; the SDK
 schedules them on a worker and persists the results in event history.
 """
 
-from datetime import timedelta
-
 import base64
 import mimetypes
+from datetime import timedelta
 from pathlib import Path
 from urllib.parse import unquote
 from urllib.request import url2pathname
@@ -34,9 +33,7 @@ def _confined_local_path(raw_path: str) -> Path:
     candidate = Path(raw_path)
     candidate = (candidate if candidate.is_absolute() else root / candidate).resolve()
     if not candidate.is_relative_to(root):
-        raise ValueError(
-            f"Refusing to read '{candidate}': outside the project directory '{root}'."
-        )
+        raise ValueError(f"Refusing to read '{candidate}': outside the project directory '{root}'.")
     return candidate
 
 
@@ -121,9 +118,7 @@ async def classify_cargo_type(extracted_text: str) -> CargoClassification:
     retry_policy_max_attempts=2,
     start_to_close_timeout=timedelta(minutes=1),
 )
-async def validate_dangerous_goods(
-    extracted_text: str, shipment_id: str
-) -> DangerousGoodsResult:
+async def validate_dangerous_goods(extracted_text: str, shipment_id: str) -> DangerousGoodsResult:
     """Run a structured-output LLM call to extract UN number, hazard class, and anomalies.
 
     This activity is called from DangerousGoodsValidationWorkflow (the sub-workflow),
@@ -142,10 +137,7 @@ async def validate_dangerous_goods(
                 )
             ),
             workflows_mistralai.UserMessage(
-                content=(
-                    f"Shipment ID: {shipment_id}\n\n"
-                    f"Shipping document extract:\n\n{extracted_text}"
-                )
+                content=(f"Shipment ID: {shipment_id}\n\nShipping document extract:\n\n{extracted_text}")
             ),
         ],
     )
@@ -157,9 +149,7 @@ async def validate_dangerous_goods(
     retry_policy_max_attempts=2,
     start_to_close_timeout=timedelta(minutes=1),
 )
-async def validate_customs_compliance(
-    extracted_text: str, cargo_type: str, shipment_id: str
-) -> ComplianceCheck:
+async def validate_customs_compliance(extracted_text: str, cargo_type: str, shipment_id: str) -> ComplianceCheck:
     """Check the document against standard customs rules.
 
     Validates presence of: HS code, country of origin, consignee details,

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/src/mistral_workflows_cli/_template/template/src/examples/cargo_release/models.py

@@ -13,9 +13,7 @@ from pydantic import BaseModel, Field
 class CargoReleaseInput(BaseModel):
     """Single entrypoint model — fields become top-level JSON input keys."""
 
-    document_uri: str = Field(
-        description="Local file path or URL of the shipping document to process"
-    )
+    document_uri: str = Field(description="Local file path or URL of the shipping document to process")
     shipment_id: str = Field(description="Unique identifier for this shipment")
 
 
@@ -36,9 +34,7 @@ class DangerousGoodsParams(BaseModel):
 class DangerousGoodsResult(BaseModel):
     """Structured output from the dangerous-goods validation sub-workflow."""
 
-    un_number: str | None = Field(
-        default=None, description="UN number if present, e.g. 'UN 1203'"
-    )
+    un_number: str | None = Field(default=None, description="UN number if present, e.g. 'UN 1203'")
     hazard_class: str | None = Field(
         default=None,
         description="IMO/ADR hazard class, e.g. 'Class 3 - Flammable liquids'",
@@ -47,9 +43,7 @@ class DangerousGoodsResult(BaseModel):
         default_factory=list,
         description="List of compliance anomalies found (e.g. missing emergency contact)",
     )
-    has_anomaly: bool = Field(
-        description="True if any anomaly was detected that requires human review"
-    )
+    has_anomaly: bool = Field(description="True if any anomaly was detected that requires human review")
 
 
 class ComplianceCheck(BaseModel):

{mistralai_workflows_cli-1.2.1 → mistralai_workflows_cli-1.2.2}/src/mistral_workflows_cli/_template/template/src/examples/cargo_release/workflow.py

@@ -41,8 +41,7 @@ _CARGO_NAME = "cargo-release-compliance"
     name=_DG_NAME,
     workflow_display_name="Dangerous Goods Validation",
     workflow_description=(
-        "Sub-workflow: extract UN number, hazard class, and anomalies "
-        "from a dangerous goods shipping document."
+        "Sub-workflow: extract UN number, hazard class, and anomalies from a dangerous goods shipping document."
     ),
 )
 class DangerousGoodsValidationWorkflow:
@@ -141,21 +140,15 @@ class CargoReleaseWorkflow(workflows.InteractiveWorkflow):
         #   a) the dangerous-goods sub-workflow found something wrong, OR
         #   b) customs compliance failed.
         # This boolean is computed from recorded activity results → deterministic.
-        anomaly_detected = (dg_result is not None and dg_result.has_anomaly) or (
-            not compliance.passed
-        )
+        anomaly_detected = (dg_result is not None and dg_result.has_anomaly) or (not compliance.passed)
 
         if anomaly_detected:
             # Build a human-readable summary for the reviewer.
             anomaly_summary_parts: list[str] = []
             if dg_result and dg_result.anomalies:
-                anomaly_summary_parts.append(
-                    "Dangerous goods anomalies: " + "; ".join(dg_result.anomalies)
-                )
+                anomaly_summary_parts.append("Dangerous goods anomalies: " + "; ".join(dg_result.anomalies))
             if not compliance.passed:
-                anomaly_summary_parts.append(
-                    "Customs compliance failures: " + ", ".join(compliance.failed_rules)
-                )
+                anomaly_summary_parts.append("Customs compliance failures: " + ", ".join(compliance.failed_rules))
             anomaly_summary = " | ".join(anomaly_summary_parts)
 
             await workflows_mistralai.send_assistant_message(