Function env_encode_error 

pub fn env_encode_error(key: &str, err: Error) -> SError

Convert an environment serialization failure into a structured workflow error.

This function is public because exported macros use it in generated code. It is not usually called directly by workflow authors.

Examples found in repository

examples/tool_calling_and_web_searching.rs (line 592)

fn receive_response(
    workflow: &mut Workflow,
    mut state: ToolLoopState,
    response: Message,
    continuation: Continuation,
    output_key: &str,
    results_key: &str,
    after_function: &str,
) -> Result<(ToolLoopState, ContinuationChoice), handled::SError> {
    (|| {
        state.messages.push(MessageParam::from(response.clone()));

        let tool_uses = client_tool_uses(&response);
        if !tool_uses.is_empty() {
            let requested = tool_uses.len() as u32;
            if state.tool_calls_used.saturating_add(requested) > state.max_tool_calls {
                return Err(demo_error(
                    "tool-call-budget-exhausted",
                    "model exceeded the text_editor tool-call budget",
                )
                .with_string_field("required_file", &state.required_file)
                .with_atom_field("max_tool_calls", state.max_tool_calls)
                .with_atom_field("tool_calls_used", state.tool_calls_used)
                .with_atom_field("requested_tool_calls", requested));
            }
            state.tool_calls_used += requested;
            // Suspend: the runtime runs each tool_use through the registered
            // tool and resumes at `after_function` with the results.
            return Ok((
                state,
                continuation.tool_call(tool_uses, results_key, after_function),
            ));
        }

        if matches!(response.stop_reason, Some(StopReason::ToolUse)) {
            return Err(demo_error(
                "unsupported-tool-use",
                "model requested tool use but no client-side text editor tool call was present",
            )
            .with_string_field("required_file", &state.required_file));
        }

        let output = read_required_output(&state)?;
        workflow
            .into_env(output_key, output)
            .map_err(|err| langcontinuation::env_encode_error(output_key, err))?;
        Ok((state, continuation.halt()))
    })()
}