Method parallel_resumable

sdk/python/src/lib.rs:1557–1587

Like `parallel`, but resumable: progress is journaled under `workflow_id` via the session's store, so an interrupted run skips already-completed steps. Raises if no `session_store` is configured.

(
        &self,
        py: Python<'_>,
        specs: Vec<Bound<'_, PyAny>>,
        workflow_id: String,
    )

    /// `workflow_id` via the session's store, so an interrupted run skips
    /// already-completed steps. Raises if no `session_store` is configured.
    fn parallel_resumable(
        &self,
        py: Python<'_>,
        specs: Vec<Bound<'_, PyAny>>,
        workflow_id: String,
    ) -> PyResult<Vec<PyObject>> {
        let rust_specs = specs
            .iter()
            .map(|s| py_to_step_spec(py, s))
            .collect::<PyResult<Vec<_>>>()?;
        let session = self.inner.clone();
        let outcomes = py
            .allow_threads(move || {
                get_runtime().block_on(async move {
                    let Some(store) = session.session_store() else {
                        return Err("parallel_resumable requires a session_store on the session");
                    };
                    let executor = session.agent_executor();
                    Ok(execute_steps_parallel_resumable(
                        executor,
                        rust_specs,
                        &workflow_id,
                        store,
                        None,
                    )
                    .await)
                })
            })
            .map_err(PyRuntimeError::new_err)?;
        outcomes.iter().map(|o| step_outcome_to_py(py, o)).collect()
    }

    /// Run each item through a chain of `stages`, with no barrier between
    /// stages. Each stage is a callable `stage(ctx) -> spec_dict | None`, where