Skip to main content

Executions

Executions are individual runs of a workflow. Use this resource to inspect run status, per-node spans, logs, and progress, and to pause, resume, or cancel a run.

Access it as client.executions on a Strongly client, or the same path on AsyncStrongly with await. All methods exist on both with identical signatures.

Quick start​

from strongly import Strongly

client = Strongly()

# List (auto-paginates as you iterate)  # filters: workflow_id, status, since, until, trigger_type
for execution in client.executions.list():
    print(execution.id)

# Retrieve one by id
item = client.executions.retrieve("<id>")

Methods​

Core​

list​

list(*, workflow_id: str | None = None, status: str | None = None, since: str | None = None, until: str | None = None, trigger_type: str | None = None, limit: int | None = None) -> SyncPaginator[Execution]

List workflow executions with pagination and filtering.

Parameters

  • workflow_id (str | None, optional): One workflow's runs; omitted, the runs of every workflow you can see.
  • status (str | None, optional): Filter by execution status: "pending", "running", "completed", "completed_with_gaps", "partial_success", "failed", "stopped", "cancelled", "error" or "timeout".
  • since (str | None, optional): ISO timestamp; only return executions created after this time.
  • until (str | None, optional): ISO timestamp; only return executions created before this time.
  • trigger_type (str | None, optional): Filter by trigger type (e.g. "manual", "api", "schedule").
  • limit (int | None, optional): Maximum number of items to return (default: all matching items).

retrieve​

retrieve(execution_id: str) -> Execution

Get a single execution with full details.

Lifecycle & actions​

stop​

stop(execution_id: str) -> dict[str, Any]

Stop a running execution. Only a run in "running" status can be stopped.

resume​

resume(execution_id: str, *, trigger_data: Mapping[str, Any] | None = None) -> Execution

Resume a failed or paused execution.

Parameters

  • execution_id (str): The execution ID.
  • trigger_data (Mapping[str, Any] | None, optional): Optional data to pass when resuming (free-form).

cancel​

cancel(execution_id: str) -> Execution

Cancel an execution that has not finished (pending, queued or running).

The run is marked "cancelled" at once. Cancelling a run that has already finished changes nothing and returns its final status.

Other​

discard_dead_letter​

discard_dead_letter(dead_letter_id: str, *, notes: str | None = None) -> DeadLetter

Give up on a dead letter: it is never retried. notes say why.

list_dead_letters​

list_dead_letters(*, workflow_id: str | None = None, status: str | None = None) -> SyncPaginator[DeadLetter]

List the runs that could not be submitted (dead letters), newest failure first.

Parameters

  • workflow_id (str | None, optional): One workflow's; omitted, every workflow's you can see.
  • status (str | None, optional): Only entries in this status: pending, retrying, resolved, exhausted or discarded (comma-separated for several).

logs​

logs(execution_id: str, *, level: str | None = None, limit: int | None = None) -> list[ExecutionLog]

Get logs for an execution.

Parameters

  • execution_id (str): The execution ID.
  • level (str | None, optional): Optional log level filter (e.g. "error", "info").
  • limit (int | None, optional): Maximum number of log entries (default 100, max 1000).

notify_input_request​

notify_input_request(execution_id: str, request_id: str) -> dict[str, Any]

Send a waiting human-input request's notification again.

Parameters

  • execution_id (str): The execution's ID.
  • request_id (str): The human-input request's ID (from pending_inputs).

pending_inputs​

pending_inputs(execution_id: str) -> list[dict[str, Any]]

List what a running execution waits on from a person.

Each request has type ("input", "feedback" or "checkpoint"), request_id (pass it to submit_input), node_id, and what the request asks: prompt and input_schema (input); prompt, feedback_type, ratingScale, choices, form_fields (feedback); title, description, data, approvers, input_fields (checkpoint).

Parameters

  • execution_id (str): The execution ID.

Returns

  • list[dict[str, Any]]: The pending requests, each with at least request_id, type and node_id.

progress​

progress(execution_id: str) -> ExecutionProgress

Get an execution's status and progress.

Waits up to about 9 seconds for the run to finish before answering, so call it again while is_terminal is False. Once the run finished as completed, completed_with_gaps or partial_success the result carries a per-node outputs preview, and next_action says what to check (for example, which nodes produced nothing).

retrieve_dead_letter​

retrieve_dead_letter(dead_letter_id: str) -> DeadLetter

Get a dead letter and where its retries stand.

retry_dead_letter​

retry_dead_letter(dead_letter_id: str) -> dict[str, Any]

Retry a dead letter now, as you.

Returns outcome (resolved, pending, exhausted, reverted or unknown), with the execution_id of the run when it started, or the error.

spans​

spans(execution_id: str, *, node_id: str | None = None) -> list[ExecutionSpan]

List spans (node-level trace records) for an execution.

Parameters

  • execution_id (str): The execution ID.
  • node_id (str | None, optional): Optional filter by specific node ID.

submit_input​

submit_input(execution_id: str, *, request_id: str, data: Any) -> dict[str, Any]

Answer a pending request of a running workflow execution.

Wait for Input, Human Feedback and Human Checkpoint nodes pause a run (its status stays "running") until a person answers; list what a run waits on with pending_inputs. The run continues within seconds of the answer. The respondent is the API key's user.

Parameters

  • execution_id (str): The execution ID.

  • request_id (str): The pending request's requestId (from pending_inputs).

  • data (Any): The answer, shaped by the request's type:

    • "input": any JSON value (matching the node's input schema when it has one)
    • "feedback": text -> a string; rating -> a number from 1 to ratingScale; choice -> one of choices; form -> a dict with every required form field
    • "checkpoint": &#123;"decision": "approved" | "rejected", "message": "...", "input": &#123;...&#125;&#125;; only an approver can decide when approvers are set