slumber-python 5.1.1__tar.gz → 5.2.0__tar.gz

{slumber_python-5.1.1 → slumber_python-5.2.0}/Cargo.lock

@@ -809,7 +809,7 @@ dependencies = [
 
 [[package]]
 name = "doc_utils"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -3280,7 +3280,7 @@ checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slumber"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "anyhow",
  "console-subscriber",
@@ -3294,7 +3294,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_cli"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -3329,7 +3329,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_config"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "derive_more",
  "dirs",
@@ -3354,7 +3354,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_core"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "async-trait",
  "base64 0.22.1",
@@ -3402,7 +3402,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_import"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "anyhow",
  "base64 0.22.1",
@@ -3434,7 +3434,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_macros"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3443,7 +3443,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_python"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "async-trait",
  "dialoguer",
@@ -3457,7 +3457,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_template"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "bytes",
  "derive_more",
@@ -3484,7 +3484,7 @@ dependencies = [
 
 [[package]]
 name = "slumber_tui"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3520,12 +3520,13 @@ dependencies = [
  "tree-sitter-json",
  "unicode-width",
  "uuid",
+ "winnow",
  "wiremock",
 ]
 
 [[package]]
 name = "slumber_util"
-version = "5.1.1"
+version = "5.2.0"
 dependencies = [
  "derive_more",
  "dirs",

{slumber_python-5.1.1 → slumber_python-5.2.0}/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://slumber.lucaspickering.me"
 keywords = ["rest", "http", "terminal", "tui"]
 license = "MIT"
 repository = "https://github.com/LucasPickering/slumber"
-version = "5.1.1"
+version = "5.2.0"
 # Keep in sync w/ rust-toolchain.toml
 rust-version = "1.90.0"
 
@@ -43,14 +43,14 @@ serde_json = {version = "1.0.120", default-features = false, features = ["preser
 serde_json_path = "0.7.1"
 serde_test = "1.0.176"
 serde_yaml = {version = "0.9.0", default-features = false}
-slumber_cli = {path = "./crates/cli", version = "5.1.1" }
-slumber_config = {path = "./crates/config", version = "5.1.1", default-features = false }
-slumber_core = {path = "./crates/core", version = "5.1.1" }
-slumber_import = {path = "./crates/import", version = "5.1.1" }
-slumber_macros = {path = "./crates/macros", version = "5.1.1" }
-slumber_template = {path = "./crates/template", version = "5.1.1" }
-slumber_tui = {path = "./crates/tui", version = "5.1.1" }
-slumber_util = {path = "./crates/util", version = "5.1.1" }
+slumber_cli = {path = "./crates/cli", version = "5.2.0" }
+slumber_config = {path = "./crates/config", version = "5.2.0", default-features = false }
+slumber_core = {path = "./crates/core", version = "5.2.0" }
+slumber_import = {path = "./crates/import", version = "5.2.0" }
+slumber_macros = {path = "./crates/macros", version = "5.2.0" }
+slumber_template = {path = "./crates/template", version = "5.2.0" }
+slumber_tui = {path = "./crates/tui", version = "5.2.0" }
+slumber_util = {path = "./crates/util", version = "5.2.0" }
 strum = {version = "0.27.0", default-features = false}
 syn = "2.0.101"
 terminput = "0.5.3"

{slumber_python-5.1.1 → slumber_python-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slumber-python
-Version: 5.1.1
+Version: 5.2.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/collection/cereal.rs

@@ -9,9 +9,9 @@
 
 use crate::{
     collection::{
-        Authentication, Collection, Folder, JsonTemplate, Profile, ProfileId,
+        Authentication, Collection, Folder, Profile, ProfileId,
         QueryParameterValue, Recipe, RecipeBody, RecipeId, RecipeTree,
-        recipe_tree::RecipeNode,
+        ValueTemplate, recipe_tree::RecipeNode,
     },
     http::HttpMethod,
 };
@@ -383,7 +383,7 @@ impl DeserializeYaml for RecipeBody {
     }
 }
 
-impl DeserializeYaml for JsonTemplate {
+impl DeserializeYaml for ValueTemplate {
     fn expected() -> Expected {
         Expected::OneOf(&[
             &Expected::Null,
@@ -404,16 +404,9 @@ impl DeserializeYaml for JsonTemplate {
             | YamlData::BadValue
             | YamlData::Alias(_) => yaml_parse_panic(),
             YamlData::Value(Scalar::Null) => Ok(Self::Null),
-            YamlData::Value(Scalar::Boolean(b)) => Ok(Self::Bool(b)),
-            YamlData::Value(Scalar::Integer(i)) => Ok(Self::Number(i.into())),
-            YamlData::Value(Scalar::FloatingPoint(f)) => Ok(Self::Number(
-                serde_json::Number::from_f64(f.0).ok_or_else(|| {
-                    LocatedError::other(
-                        CerealError::InvalidJsonFloat(f.0),
-                        yaml.location,
-                    )
-                })?,
-            )),
+            YamlData::Value(Scalar::Boolean(b)) => Ok(Self::Boolean(b)),
+            YamlData::Value(Scalar::Integer(i)) => Ok(Self::Integer(i)),
+            YamlData::Value(Scalar::FloatingPoint(f)) => Ok(Self::Float(f.0)),
             // Parse string as a template
             YamlData::Value(Scalar::String(s)) => {
                 let template = s.parse::<Template>().map_err(|error| {
@@ -451,10 +444,6 @@ impl DeserializeYaml for JsonTemplate {
 /// only holds errors specific to collection deserialization.
 #[derive(Debug, thiserror::Error)]
 enum CerealError {
-    /// JSON body contained a float value that isn't representable in JSON
-    #[error("Invalid float `{0}`; JSON does not support NaN or Infinity")]
-    InvalidJsonFloat(f64),
-
     #[error(
         "Cannot set profile `{second}` as default; `{first}` is already default"
     )]

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/collection/models.rs

@@ -2,8 +2,7 @@
 
 use crate::{
     collection::{
-        cereal,
-        json::JsonTemplate,
+        ValueTemplate, cereal,
         recipe_tree::{RecipeNode, RecipeTree},
     },
     http::HttpMethod,
@@ -119,10 +118,12 @@ impl Collection {
 impl slumber_util::Factory for Collection {
     fn factory((): ()) -> Self {
         use crate::test_util::by_id;
+        use serde_json::json;
+
         // Include a body in the recipe, so body-related behavior can be tested
         let recipe = Recipe {
             body: Some(RecipeBody::Json(
-                r#"{"message": "hello"}"#.parse().unwrap(),
+                json!({"message": "hello"}).try_into().unwrap(),
             )),
             ..Recipe::factory(())
         };
@@ -157,7 +158,8 @@ pub struct Profile {
     #[serde(skip_serializing_if = "cereal::is_false")] // Skip if default
     #[cfg_attr(feature = "schema", schemars(default))]
     pub default: bool,
-    pub data: IndexMap<String, Template>,
+    /// Arbitrary data that can be used in templates
+    pub data: IndexMap<String, ValueTemplate>,
 }
 
 impl Profile {
@@ -513,7 +515,7 @@ impl<const N: usize> From<[&'static str; N]> for QueryParameterValue {
 pub enum RecipeBody {
     /// `application/json` body. Value can be any JSON value, with strings being
     /// interpreted as templates
-    Json(JsonTemplate),
+    Json(ValueTemplate),
     /// `application/x-www-form-urlencoded` body. Value is a mapping of form
     /// field name to value. Values are templates while field names are not.
     /// Values must render to strings.
@@ -541,7 +543,7 @@ impl RecipeBody {
     /// Build a JSON body *without* parsing the internal strings as templates.
     /// Useful for importing from external formats.
     pub fn untemplated_json(value: serde_json::Value) -> Self {
-        Self::Json(JsonTemplate::raw(value))
+        Self::Json(ValueTemplate::from_raw_json(value))
     }
 
     /// Get the anticipated MIME type that will appear in the `Content-Type`

slumber_python-5.2.0/crates/core/src/collection/value_template.rs

@@ -0,0 +1,163 @@
+use crate::render::TemplateContext;
+use futures::{FutureExt, future};
+use serde::Serialize;
+use slumber_template::{
+    RenderError, RenderedChunks, Template, Value, ValueStream,
+};
+
+/// A templated [Value]
+///
+/// This is a [Value], except the strings are templates. That means this can be
+/// dynamically rendered to a [Value]. This is used for structured bodies (e.g.
+/// JSON) as well as profile fields.
+#[derive(Clone, Debug, derive_more::From, PartialEq, Serialize)]
+#[serde(untagged)]
+#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
+pub enum ValueTemplate {
+    Null,
+    Boolean(bool),
+    Integer(i64),
+    Float(f64),
+    String(Template),
+    #[from(ignore)]
+    Array(Vec<Self>),
+    // A key-value mapping. Stored as a `Vec` instead of `IndexMap` because
+    // the keys are templates, which aren't hashable. We never do key lookups
+    // on this so there's no need for a map anyway.
+    #[from(ignore)]
+    #[serde(serialize_with = "slumber_util::serialize_mapping")]
+    #[cfg_attr(
+        feature = "schema",
+        schemars(with = "std::collections::HashMap<Template, Self>")
+    )]
+    Object(Vec<(Template, Self)>),
+}
+
+impl ValueTemplate {
+    /// Create a new string template from a raw string, without parsing it at
+    /// all
+    ///
+    /// Useful when importing from external formats where the string isn't
+    /// expected to be a valid Slumber template
+    pub fn raw(template: String) -> Self {
+        Self::String(Template::raw(template))
+    }
+
+    /// Does the template have at least one dynamic chunk? If this returns
+    /// `false`, the template will always render to its source text
+    pub fn is_dynamic(&self) -> bool {
+        match self {
+            Self::Null
+            | Self::Boolean(_)
+            | Self::Integer(_)
+            | Self::Float(_) => false,
+            Self::String(template) => template.is_dynamic(),
+            Self::Array(array) => array.iter().any(Self::is_dynamic),
+            Self::Object(object) => object
+                .iter()
+                .any(|(key, value)| key.is_dynamic() || value.is_dynamic()),
+        }
+    }
+
+    /// Render to chunks with eager values
+    ///
+    /// The return value is *usually* a single chunk, but if `self` is a
+    /// multi-chunk template string, then its multi-chunk output will be the
+    /// output for this.
+    ///
+    /// Use this for cases where streaming is *not* allowed.
+    pub async fn render_chunks(
+        &self,
+        context: &TemplateContext,
+    ) -> RenderedChunks<Value> {
+        self.render_chunks_inner(context, Template::render_chunks)
+            .await
+    }
+
+    /// Render to chunks with stream values
+    ///
+    /// The return value is *usually* a single chunk, but if `self` is a
+    /// multi-chunk template string, then its multi-chunk output will be the
+    /// output for this.
+    ///
+    /// Use this for cases where streaming is allowed.
+    pub async fn render_chunks_stream(
+        &self,
+        context: &TemplateContext,
+    ) -> RenderedChunks<ValueStream> {
+        self.render_chunks_inner(context, Template::render_chunks_stream)
+            .await
+    }
+
+    /// Render to chunks with dynamic output type
+    async fn render_chunks_inner<V>(
+        &self,
+        context: &TemplateContext,
+        render_string: impl AsyncFn(
+            &Template,
+            &TemplateContext,
+        ) -> RenderedChunks<V>,
+    ) -> RenderedChunks<V>
+    where
+        V: From<Value>,
+    {
+        match self {
+            Self::Null => Value::Null.into(),
+            Self::Boolean(b) => Value::Boolean(*b).into(),
+            Self::Integer(i) => Value::Integer(*i).into(),
+            Self::Float(f) => Value::Float(*f).into(),
+            Self::String(template) => render_string(template, context).await,
+            Self::Array(array) => {
+                // Render each value and collection into an Array
+                future::try_join_all(array.iter().map(|value| {
+                    value
+                        .render_chunks(context)
+                        .map(RenderedChunks::try_into_value)
+                }))
+                .await
+                .map(Value::from)
+                .into() // Wrap into RenderedOutput
+            }
+            Self::Object(map) => {
+                // Render each key/value and collect into an Object
+                future::try_join_all(map.iter().map(|(key, value)| async {
+                    let key = key.render_string(context).await?;
+                    let value =
+                        value.render_chunks(context).await.try_into_value()?;
+                    Ok::<_, RenderError>((key, value))
+                }))
+                .await
+                .map(Value::from)
+                .into() // Wrap into RenderedOutput
+            }
+        }
+    }
+}
+
+/// Parse template from a string literal. Panic if invalid
+#[cfg(any(test, feature = "test"))]
+impl From<&str> for ValueTemplate {
+    fn from(value: &str) -> Self {
+        let template = value.parse().unwrap();
+        Self::String(template)
+    }
+}
+
+#[cfg(any(test, feature = "test"))]
+impl<T: Into<ValueTemplate>> From<Vec<T>> for ValueTemplate {
+    fn from(value: Vec<T>) -> Self {
+        Self::Array(value.into_iter().map(T::into).collect())
+    }
+}
+
+#[cfg(any(test, feature = "test"))]
+impl<T: Into<ValueTemplate>> From<Vec<(&str, T)>> for ValueTemplate {
+    fn from(value: Vec<(&str, T)>) -> Self {
+        Self::Object(
+            value
+                .into_iter()
+                .map(|(k, v)| (k.parse().unwrap(), v.into()))
+                .collect(),
+        )
+    }
+}

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/collection.rs

@@ -2,16 +2,16 @@
 //! possible
 
 mod cereal;
-mod json;
 mod models;
 mod recipe_tree;
 #[cfg(feature = "schema")]
 mod schema;
+mod value_template;
 
 pub use cereal::HasId;
-pub use json::{JsonTemplate, JsonTemplateError};
 pub use models::*;
 pub use recipe_tree::*;
+pub use value_template::ValueTemplate;
 
 use itertools::Itertools;
 use std::{
@@ -337,11 +337,21 @@ requests:
                     name: Some("Profile 1".into()),
                     default: false,
                     data: indexmap! {
+                        "host".into() => "https://httpbin.org".into(),
                         "user_guid".into() => "abc123".into(),
                         "username".into() =>
                             "xX{{ command(['whoami']) | trim() }}Xx".into(),
-                        "host".into() => "https://httpbin.org".into(),
-
+                        "null".into() => ValueTemplate::Null,
+                        "bool".into() => true.into(),
+                        "int".into() => 4.into(),
+                        "float".into() => 123.45.into(),
+                        "array".into() => ValueTemplate::Array(
+                            vec![1.into(), 2.into(), "test".into()]
+                        ),
+                        "object".into() => ValueTemplate::Object(vec![
+                            ("a".into(), 1.into()),
+                            ("b".into(), vec![1, 2, 7].into()),
+                        ]),
                     },
                     ..Profile::factory(())
                 },

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/http/models.rs

@@ -3,9 +3,11 @@
 //! stages, meaning the request or response may not actually be present, if the
 //! exchange is incomplete or failed.
 
-use crate::collection::{
-    Authentication, JsonTemplate, JsonTemplateError, ProfileId, RecipeId,
-    UnknownRecipeError,
+use crate::{
+    collection::{
+        Authentication, ProfileId, RecipeId, UnknownRecipeError, ValueTemplate,
+    },
+    util::json::JsonTemplateError,
 };
 use bytes::Bytes;
 use chrono::{DateTime, Duration, Utc};
@@ -343,7 +345,7 @@ pub enum BodyOverride {
     /// stream
     Raw(Template),
     /// Override with a JSON value
-    Json(JsonTemplate),
+    Json(ValueTemplate),
 }
 
 #[cfg(any(test, feature = "test"))]

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/http/tests.rs

@@ -34,18 +34,19 @@ thread_local! {
 /// collection
 fn template_context(recipe: Recipe, host: Option<&str>) -> TemplateContext {
     let profile_data = indexmap! {
-        "host".into() => host.unwrap_or("http://localhost").parse().unwrap(),
+        "host".into() => host.unwrap_or("http://localhost").into(),
         "mode".into() => "sudo".into(),
         "user_id".into() => "1".into(),
         "group_id".into() => "3".into(),
         "username".into() => "user".into(),
         "password".into() => "hunter2".into(),
         "token".into() => "tokenzzz".into(),
-        "test_data_dir".into() => test_data_dir().to_str().unwrap().parse().unwrap(),
+        "test_data_dir".into() => test_data_dir().to_str().unwrap().into(),
         "prompt".into() => "{{ prompt() }}".into(),
         "stream".into() => "{{ file('data.json') }}".into(),
         // Streamed value that we can use to test deduping
         "stream_prompt".into() => "{{ file(concat([prompt(), '.txt'])) }}".into(),
+        "stream_compound".into() => "inner: {{ file('first.txt') }}".into(),
         "error".into() => "{{ fake_fn() }}".into(),
     };
     let profile = Profile {
@@ -401,7 +402,7 @@ async fn test_authentication(
     // JSON data is loaded as a string and NOT unpacked. file() returns bytes
     // which automatically get interpreted as a string.
     RecipeBody::json(json!(
-        "{{ file(concat([test_data_dir, '/data.json'])) | trim() }}"
+        "{{ file(concat([test_data_dir, '/data.json'])) }}"
     )).unwrap(),
     None,
     Some("application/json"),
@@ -498,12 +499,18 @@ async fn test_body(
     None,
     r#"{ "a": 1, "b": 2 }"#,
 )]
-#[case::stream_multichunk(
+#[case::stream_compound(
     // This gets streamed one chunk at a time
     RecipeBody::Stream(r#"{ "data": {{ file('data.json') }} }"#.into()),
     None,
     r#"{ "data": { "a": 1, "b": 2 } }"#,
 )]
+// Stream multiple chunks of data via a profile field
+#[case::stream_compound_nested(
+    RecipeBody::Stream("outer: {{ stream_compound }}".into()),
+    None,
+    "outer: inner: first",
+)]
 #[case::form_multipart(
     RecipeBody::FormMultipart(indexmap! {
         "user_id".into() => "{{ user_id }}".into(),

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/http.rs

@@ -47,6 +47,7 @@ use crate::{
     database::CollectionDatabase,
     http::curl::CurlBuilder,
     render::TemplateContext,
+    util::json::value_to_json,
 };
 use bytes::{Bytes, BytesMut};
 use chrono::Utc;
@@ -747,9 +748,9 @@ impl Recipe {
                 Some(BodyOverride::Raw(template)),
             ) => {
                 // Stream body is rendered as a stream (!!)
-                let output = template.render(&context.stream()).await;
-                let source = output.stream_source().cloned();
-                let stream = output
+                let chunks = template.render_chunks_stream(context).await;
+                let source = chunks.stream_source().cloned();
+                let stream = chunks
                     .try_into_stream()
                     .map_err(RequestBuildErrorKind::BodyRender)?
                     .boxed();
@@ -763,10 +764,14 @@ impl Recipe {
             | (Some(RecipeBody::Raw(_)), Some(BodyOverride::Json(json)))
             | (Some(RecipeBody::Stream(_)), Some(BodyOverride::Json(json)))
             | (Some(RecipeBody::Json(_)), Some(BodyOverride::Json(json))) => {
-                json.render_json(context)
+                // Render the value
+                let rendered_value = json
+                    .render_chunks(context)
                     .await
-                    .map(|value| Some(RenderedBody::Json(value)))
-                    .map_err(RequestBuildErrorKind::BodyRender)
+                    .try_into_value()
+                    .map_err(RequestBuildErrorKind::BodyRender)?;
+                let json = value_to_json(rendered_value);
+                Ok(Some(RenderedBody::Json(json)))
             }
 
             // Form bodies
@@ -789,13 +794,13 @@ impl Recipe {
             (Some(RecipeBody::FormMultipart(fields)), None) => {
                 let merged = apply_overrides(fields, &options.form_fields);
                 let iter = merged.into_iter().map(async |(field, template)| {
-                    let output = template.render(&context.stream()).await;
+                    let chunks = template.render_chunks_stream(context).await;
                     // If this is a single-chunk template, we might be able to
                     // load directly from the source, since we support file
                     // streams natively. In that case, the stream will be thrown
                     // away
-                    let source = output.stream_source().cloned();
-                    let stream = output
+                    let source = chunks.stream_source().cloned();
+                    let stream = chunks
                         .try_into_stream()
                         .map_err(|error| {
                             RequestBuildErrorKind::BodyFormFieldRender {

{slumber_python-5.1.1 → slumber_python-5.2.0}/crates/core/src/render/functions.rs

@@ -13,8 +13,8 @@ use regex::Regex;
 use serde::{Deserialize, de::IntoDeserializer};
 use slumber_macros::template;
 use slumber_template::{
-    Expected, LazyValue, RenderError, StreamSource, TryFromValue, Value,
-    ValueError, WithValue, impl_try_from_value_str,
+    Expected, RenderError, StreamSource, TryFromValue, Value, ValueError,
+    ValueStream, WithValue, impl_try_from_value_str,
 };
 use slumber_util::{TimeSpan, paths::expand_home};
 use std::{
@@ -112,7 +112,7 @@ pub fn boolean(value: Value) -> bool {
 ///   stdin:
 ///     description: Data to pipe to the subprocess's stdin
 ///     default: "b''"
-/// return: Stdout output as bytes. May be returned as a stream (LazyValue).
+/// return: Stdout output as bytes
 /// errors:
 ///   - If the command fails to initialize (e.g. program unknown)
 ///   - If the subprocess exits with a non-zero status code
@@ -128,7 +128,7 @@ pub fn command(
     command: Vec<String>,
     #[kwarg] cwd: Option<String>,
     #[kwarg] stdin: Option<Bytes>,
-) -> Result<LazyValue, FunctionError> {
+) -> Result<ValueStream, FunctionError> {
     /// Wrap an IO error
     fn io_error(
         program: &str,
@@ -222,7 +222,7 @@ pub fn command(
 
     let stream = future.try_flatten_stream().boxed();
 
-    Ok(LazyValue::Stream {
+    Ok(ValueStream::Stream {
         source: StreamSource::Command { command },
         stream,
     })
@@ -304,7 +304,7 @@ pub fn env(variable: String, #[kwarg] default: String) -> String {
 ///     output: Contents of config.json file
 /// ```
 #[template]
-pub fn file(#[context] context: &TemplateContext, path: String) -> LazyValue {
+pub fn file(#[context] context: &TemplateContext, path: String) -> ValueStream {
     let path = context.root_dir.join(expand_home(PathBuf::from(path)));
     let source = StreamSource::File { path: path.clone() };
     // Return the file as a stream. If streaming isn't available here, it will
@@ -317,7 +317,7 @@ pub fn file(#[context] context: &TemplateContext, path: String) -> LazyValue {
             .map_err(|error| FunctionError::File { path, error })?;
         Ok(reader_stream(file))
     };
-    LazyValue::Stream {
+    ValueStream::Stream {
         source,
         stream: future.try_flatten_stream().boxed(),
     }
@@ -879,7 +879,7 @@ pub async fn prompt(
         sensitive,
         channel: tx.into(),
     });
-    let output = rx.await.map_err(|_| FunctionError::PromptNoReply)?;
+    let chunks = rx.await.map_err(|_| FunctionError::PromptNoReply)?;
 
     // If the input was sensitive, we should mask the output as well. This only
     // impacts previews as show_sensitive is enabled for request renders. This
@@ -888,9 +888,9 @@ pub async fn prompt(
     // "<prompt>", we show "••••••••". It's "technically" right and plays well
     // in tests. Also it reminds users that a prompt is sensitive in the TUI
     if sensitive {
-        Ok(mask_sensitive(context, output))
+        Ok(mask_sensitive(context, chunks))
     } else {
-        Ok(output)
+        Ok(chunks)
     }
 }