2025-04-19 20:19:50 +02:00
24 changed files with 179 additions and 540 deletions
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@ -8,6 +8,7 @@ env:
  CARGO_TERM_COLOR: always
  AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
  AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+  _EXPERIMENTAL_DAGGER_CACHE_CONFIG: type=gha;mode=max
 jobs:
  deploy:
    runs-on: ubuntu-latest
@ -27,10 +28,5 @@ jobs:
        uses: docker/setup-qemu-action@v2
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2.0.0
-      -
-        name: Expose GitHub Runtime
-        uses: crazy-max/ghaction-github-runtime@v2
      - name: Run dagger [CI]
-        run: |
-          export _EXPERIMENTAL_DAGGER_CACHE_CONFIG="type=gha,mode=max,url=$ACTIONS_CACHE_URL,token=$ACTIONS_RUNTIME_TOKEN"
-          cargo run -p ci -- pr
+        run: cargo run -p ci -- pr
--- a/Cargo.lock
+++ b/Cargo.lock
@ -317,7 +317,7 @@ dependencies = [

 [[package]]
 name = "dagger-core"
-version = "0.2.11"
+version = "0.2.10"
 dependencies = [
 "async-trait",
 "base64",
@ -334,7 +334,6 @@ dependencies = [
 "sha2",
 "tar",
 "tempfile",
- "thiserror",
 "tokio",
 "tracing",
 "tracing-subscriber",
@ -342,7 +341,7 @@ dependencies = [

 [[package]]
 name = "dagger-sdk"
-version = "0.2.22"
+version = "0.2.21"
 dependencies = [
 "dagger-core",
 "derive_builder",
@ -353,7 +352,6 @@ dependencies = [
 "rand",
 "serde",
 "serde_json",
- "thiserror",
 "tokio",
 "tracing",
 "tracing-subscriber",
--- a/Cargo.toml
+++ b/Cargo.toml
@ -23,4 +23,3 @@ tracing-subscriber = { version = "0.3.16", features = [
  "tracing-log",
  "tracing",
 ] }
-thiserror = "1.0.40"
--- a/README.md
+++ b/README.md
@ -1,7 +1,69 @@
 # dagger-sdk

-A dagger sdk written in rust
+A dagger sdk written in rust for rust.

-## Disclaimer:
+## Plan for next release

-Repository has moved to: https://github.com/dagger/dagger/tree/main/sdk/rust
+- [ ] Introduce [thiserror](https://docs.rs/thiserror/latest/thiserror/) for
+      better errors
+- [ ] Add compatibility with `dagger run`
+- [ ] Add open telemetry tracing to the sdk
+- [ ] Remove `id().await?` from passing to other dagger graphs, this should make
+      the design much cleaner
+- [ ] Start MkBook on how to actually use the sdk
+- [ ] Update to newest upstream release
+- [ ] Fix bugs
+  - [x] Run in conjunction with golang and other sdks
+  - [ ] Stabilize the initial `Arc<Query>` model into something more extensible
+
+## Examples
+
+See [examples](./crates/dagger-sdk/examples/)
+
+Run them like so
+
+```bash
+cargo run --example first-pipeline
+```
+
+The examples match the folder name in each directory in examples
+
+## Install
+
+Simply install like:
+
+```bash
+cargo add dagger-sdk
+```
+
+### Usage
+
+```rust
+#[tokio::main]
+async fn main() -> eyre::Result<()> {
+    let client = dagger_sdk::connect().await?;
+
+    let version = client
+        .container()
+        .from("golang:1.19")
+        .with_exec(vec!["go", "version"])
+        .stdout()
+        .await?;
+
+    println!("Hello from Dagger and {}", version.trim());
+
+    Ok(())
+}
+```
+
+And run it like a normal application:
+
+```bash
+cargo run
+```
+
+### Contributing
+
+See [CONTRIBUTING](./CONTRIBUTING.md)
+
+or just cargo make codegen
--- a/ci/Cargo.toml
+++ b/ci/Cargo.toml
@ -8,6 +8,6 @@ edition = "2021"
 [dependencies]
 clap = "4.1.6"
 color-eyre = "0.6.2"
-dagger-sdk = { path = "../crates/dagger-sdk/", version = "^0.2.22" }
+dagger-sdk = { path = "../crates/dagger-sdk/", version = "^0.2.21" }
 eyre = "0.6.8"
 tokio = { version = "1.25.0", features = ["full"] }
--- a/crates/dagger-codegen/src/lib.rs
+++ b/crates/dagger-codegen/src/lib.rs
@ -13,7 +13,7 @@ use self::generator::DynGenerator;
 fn set_schema_parents(mut schema: Schema) -> Schema {
    for t in schema.types.as_mut().into_iter().flatten().flatten() {
        let t_parent = t.full_type.clone();
-        for field in t.full_type.fields.as_mut().into_iter().flatten() {
+        for mut field in t.full_type.fields.as_mut().into_iter().flatten() {
            field.parent_type = Some(t_parent.clone());
        }
    }
--- a/crates/dagger-codegen/src/rust/functions.rs
+++ b/crates/dagger-codegen/src/rust/functions.rs
@ -235,10 +235,8 @@ fn render_output_type(funcs: &CommonFunctions, type_ref: &TypeRef) -> rust::Toke
        };
    }

-    let dagger_error = rust::import("crate::errors", "DaggerError");
-
    quote! {
-        Result<$output_type, $dagger_error>
+        eyre::Result<$output_type>
    }
 }

--- a/crates/dagger-codegen/src/rust/templates/object_tmpl.rs
+++ b/crates/dagger-codegen/src/rust/templates/object_tmpl.rs
@ -18,7 +18,7 @@ pub fn render_object(funcs: &CommonFunctions, t: &FullType) -> eyre::Result<rust
    Ok(quote! {
        #[derive(Clone)]
        pub struct $(t.name.pipe(|s| format_name(s))) {
-            pub proc: Option<$arc<$child>>,
+            pub proc: $arc<$child>,
            pub selection: $selection,
            pub graphql_client: $graphql_client
        }
--- a/crates/dagger-core/CHANGELOG.md
+++ b/crates/dagger-core/CHANGELOG.md
@ -5,33 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## v0.2.11 (2023-04-29)
-
-### New Features
-
- - <csr-id-2a29a66217fa4d6c530ea1ce670c8836383e7051/> dagger-run support
- - <csr-id-eb7470c604169d1a15976078c0889d5cc7011257/> update to dagger-5.1
-
-### Commit Statistics
-
-<csr-read-only-do-not-edit/>
-
- - 2 commits contributed to the release.
- - 4 days passed between releases.
- - 2 commits were understood as [conventional](https://www.conventionalcommits.org).
- - 0 issues like '(#ID)' were seen in commit messages
-
-### Commit Details
-
-<csr-read-only-do-not-edit/>
-
-<details><summary>view details</summary>
-
- * **Uncategorized**
-    - dagger-run support ([`2a29a66`](https://github.com/kjuulh/dagger-sdk/commit/2a29a66217fa4d6c530ea1ce670c8836383e7051))
-    - update to dagger-5.1 ([`eb7470c`](https://github.com/kjuulh/dagger-sdk/commit/eb7470c604169d1a15976078c0889d5cc7011257))
-</details>
-
 ## v0.2.10 (2023-04-25)

 ### Bug Fixes
@ -42,7 +15,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 <csr-read-only-do-not-edit/>

- - 2 commits contributed to the release.
+ - 1 commit contributed to the release.
 - 21 days passed between releases.
 - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
 - 0 issues like '(#ID)' were seen in commit messages
@ -54,7 +27,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <details><summary>view details</summary>

 * **Uncategorized**
-    - Release dagger-core v0.2.10 ([`8011c42`](https://github.com/kjuulh/dagger-sdk/commit/8011c42dc077d101b1bccaf231fac17636dd249d))
    - delete other files/folder in downloads: #57 ([`9d3c21d`](https://github.com/kjuulh/dagger-sdk/commit/9d3c21d16b4a64eb7a7b1888365a4c4ea56d7225))
 </details>

--- a/crates/dagger-core/Cargo.toml
+++ b/crates/dagger-core/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "dagger-core"
-version = "0.2.11"
+version = "0.2.10"
 edition = "2021"
 readme = "README.md"
 license-file = "LICENSE.MIT"
@ -16,7 +16,6 @@ serde_json = { workspace = true }
 tokio = { workspace = true }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
-thiserror.workspace = true

 base64 = "0.21.0"
 dirs = "4.0.0"
--- a/crates/dagger-core/src/cli_session.rs
+++ b/crates/dagger-core/src/cli_session.rs
@ -89,7 +89,6 @@ impl InnerCliSession {
            while let Ok(Some(line)) = stdout_bufr.next_line().await {
                if let Ok(conn) = serde_json::from_str::<ConnectParams>(&line) {
                    sender.send(conn).await.unwrap();
-                    continue;
                }

                if let Some(logger) = &logger {
--- a/crates/dagger-core/src/engine.rs
+++ b/crates/dagger-core/src/engine.rs
@ -23,25 +23,10 @@ impl Engine {
    pub async fn start(
        &self,
        cfg: &Config,
-    ) -> eyre::Result<(ConnectParams, Option<tokio::process::Child>)> {
+    ) -> eyre::Result<(ConnectParams, tokio::process::Child)> {
        tracing::info!("starting dagger-engine");

-        if let Ok(conn) = self.from_session_env().await {
-            return Ok((conn, None));
-        }
-
-        let (conn, proc) = self.from_cli(cfg).await?;
-
-        Ok((conn, Some(proc)))
-    }
-
-    async fn from_session_env(&self) -> eyre::Result<ConnectParams> {
-        let port = std::env::var("DAGGER_SESSION_PORT").map(|p| p.parse::<u64>())??;
-        let token = std::env::var("DAGGER_SESSION_TOKEN")?;
-
-        Ok(ConnectParams {
-            port,
-            session_token: token,
-        })
+        // TODO: Add from existing session as well
+        self.from_cli(cfg).await
    }
 }
--- a/crates/dagger-core/src/gql_client.rs
+++ b/crates/dagger-core/src/gql_client.rs
@ -15,7 +15,7 @@ pub struct GraphQLError {
 #[derive(Deserialize, Debug, Clone)]
 #[allow(dead_code)]
 pub struct GraphQLErrorMessage {
-    pub message: String,
+    message: String,
    locations: Option<Vec<GraphQLErrorLocation>>,
    extensions: Option<HashMap<String, String>>,
    path: Option<Vec<GraphQLErrorPathParam>>,
--- a/crates/dagger-core/src/graphql_client.rs
+++ b/crates/dagger-core/src/graphql_client.rs
@ -4,14 +4,13 @@ use std::sync::Arc;
 use async_trait::async_trait;
 use base64::engine::general_purpose;
 use base64::Engine;
-use thiserror::Error;

 use crate::connect_params::ConnectParams;
 use crate::gql_client::{ClientConfig, GQLClient};

 #[async_trait]
 pub trait GraphQLClient {
-    async fn query(&self, query: &str) -> Result<Option<serde_json::Value>, GraphQLError>;
+    async fn query(&self, query: &str) -> eyre::Result<Option<serde_json::Value>>;
 }

 pub type DynGraphQLClient = Arc<dyn GraphQLClient + Send + Sync>;
@ -41,50 +40,13 @@ impl DefaultGraphQLClient {

 #[async_trait]
 impl GraphQLClient for DefaultGraphQLClient {
-    async fn query(&self, query: &str) -> Result<Option<serde_json::Value>, GraphQLError> {
-        let res: Option<serde_json::Value> =
-            self.client.query(&query).await.map_err(map_graphql_error)?;
+    async fn query(&self, query: &str) -> eyre::Result<Option<serde_json::Value>> {
+        let res: Option<serde_json::Value> = self
+            .client
+            .query(&query)
+            .await
+            .map_err(|r| eyre::anyhow!(r.to_string()))?;

        return Ok(res);
    }
 }
-
-fn map_graphql_error(gql_error: crate::gql_client::GraphQLError) -> GraphQLError {
-    let message = gql_error.message().to_string();
-    let json = gql_error.json();
-
-    if let Some(json) = json {
-        if !json.is_empty() {
-            return GraphQLError::DomainError {
-                message,
-                fields: GraphqlErrorMessages(json.into_iter().map(|e| e.message).collect()),
-            };
-        }
-    }
-
-    GraphQLError::HttpError(message)
-}
-
-#[derive(Error, Debug)]
-pub enum GraphQLError {
-    #[error("http error: {0}")]
-    HttpError(String),
-    #[error("domain error:\n{message}\n{fields}")]
-    DomainError {
-        message: String,
-        fields: GraphqlErrorMessages,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub struct GraphqlErrorMessages(Vec<String>);
-
-impl std::fmt::Display for GraphqlErrorMessages {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for error in self.0.iter() {
-            f.write_fmt(format_args!("{error}\n"))?;
-        }
-
-        Ok(())
-    }
-}
--- a/crates/dagger-core/src/lib.rs
+++ b/crates/dagger-core/src/lib.rs
@ -1,6 +1,6 @@
 #![deny(warnings)]

-pub const DAGGER_ENGINE_VERSION: &'static str = "0.5.1";
+pub const DAGGER_ENGINE_VERSION: &'static str = "0.4.2";

 pub mod cli_session;
 pub mod config;
--- a/crates/dagger-sdk/CHANGELOG.md
+++ b/crates/dagger-sdk/CHANGELOG.md
@ -6,37 +6,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## v0.2.22 (2023-04-29)
-
-### New Features
-
- - <csr-id-2a29a66217fa4d6c530ea1ce670c8836383e7051/> dagger-run support
- - <csr-id-eb7470c604169d1a15976078c0889d5cc7011257/> update to dagger-5.1
-
-### Commit Statistics
-
-<csr-read-only-do-not-edit/>
-
- - 2 commits contributed to the release.
- - 4 days passed between releases.
- - 2 commits were understood as [conventional](https://www.conventionalcommits.org).
- - 0 issues like '(#ID)' were seen in commit messages
-
-### Commit Details
-
-<csr-read-only-do-not-edit/>
-
-<details><summary>view details</summary>
-
- * **Uncategorized**
-    - dagger-run support ([`2a29a66`](https://github.com/kjuulh/dagger-sdk/commit/2a29a66217fa4d6c530ea1ce670c8836383e7051))
-    - update to dagger-5.1 ([`eb7470c`](https://github.com/kjuulh/dagger-sdk/commit/eb7470c604169d1a15976078c0889d5cc7011257))
-</details>
-
 ## v0.2.21 (2023-04-25)

-<csr-id-09881ee39bdfb9201d104e4679a51c3b76b5fe27/>
-
 ### Chore

 - <csr-id-09881ee39bdfb9201d104e4679a51c3b76b5fe27/> add new dagger-core-version
@ -45,7 +16,7 @@ and this project adheres to

 <csr-read-only-do-not-edit/>

- - 2 commits contributed to the release.
+ - 1 commit contributed to the release.
 - 21 days passed between releases.
 - 1 commit was understood as [conventional](https://www.conventionalcommits.org).
 - 0 issues like '(#ID)' were seen in commit messages
@ -57,7 +28,6 @@ and this project adheres to
 <details><summary>view details</summary>

 * **Uncategorized**
-    - Release dagger-sdk v0.2.21 ([`6937ef0`](https://github.com/kjuulh/dagger-sdk/commit/6937ef0ace797315013513aa7e2af39a9206a738))
    - add new dagger-core-version ([`09881ee`](https://github.com/kjuulh/dagger-sdk/commit/09881ee39bdfb9201d104e4679a51c3b76b5fe27))
 </details>

--- a/crates/dagger-sdk/Cargo.toml
+++ b/crates/dagger-sdk/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "dagger-sdk"
-version = "0.2.22"
+version = "0.2.21"
 edition = "2021"
 readme = "README.md"
 license-file = "LICENSE.MIT"
@ -11,7 +11,7 @@ publish = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-dagger-core = { workspace = true, version = "^0.2.11" }
+dagger-core = { workspace = true, version = "0.2.10" }

 eyre = { workspace = true }
 tokio = { workspace = true }
@ -19,7 +19,6 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 tracing.workspace = true
 tracing-subscriber.workspace = true
-thiserror.workspace = true

 futures = "0.3.28"
 derive_builder = "0.12.0"
--- a/crates/dagger-sdk/examples/caching/main.rs
+++ b/crates/dagger-sdk/examples/caching/main.rs
@ -7,7 +7,7 @@ async fn main() -> eyre::Result<()> {
    let host_source_dir = client.host().directory_opts(
        "./examples/caching/app",
        dagger_sdk::HostDirectoryOptsBuilder::default()
-            .exclude(vec!["node_modules/", "ci/"])
+            .exclude(vec!["node_modules", "ci/"])
            .build()?,
    );

--- a/crates/dagger-sdk/src/client.rs
+++ b/crates/dagger-sdk/src/client.rs
@ -5,27 +5,23 @@ use dagger_core::graphql_client::DefaultGraphQLClient;
 use dagger_core::config::Config;
 use dagger_core::engine::Engine as DaggerEngine;

-use crate::errors::ConnectError;
 use crate::gen::Query;
 use crate::logging::StdLogger;
 use crate::querybuilder::query;

 pub type DaggerConn = Arc<Query>;

-pub async fn connect() -> Result<DaggerConn, ConnectError> {
+pub async fn connect() -> eyre::Result<DaggerConn> {
    let cfg = Config::new(None, None, None, None, Some(Arc::new(StdLogger::default())));

    connect_opts(cfg).await
 }

-pub async fn connect_opts(cfg: Config) -> Result<DaggerConn, ConnectError> {
-    let (conn, proc) = DaggerEngine::new()
-        .start(&cfg)
-        .await
-        .map_err(ConnectError::FailedToConnect)?;
+pub async fn connect_opts(cfg: Config) -> eyre::Result<DaggerConn> {
+    let (conn, proc) = DaggerEngine::new().start(&cfg).await?;

    Ok(Arc::new(Query {
-        proc: proc.map(|p| Arc::new(p)),
+        proc: Arc::new(proc),
        selection: query(),
        graphql_client: Arc::new(DefaultGraphQLClient::new(&conn)),
    }))
--- a/crates/dagger-sdk/src/errors.rs
+++ b/crates/dagger-sdk/src/errors.rs
@ -1,27 +0,0 @@
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum ConnectError {
-    #[error("failed to connect to dagger engine")]
-    FailedToConnect(#[source] eyre::Error),
-}
-
-#[derive(Error, Debug)]
-pub enum DaggerError {
-    #[error("failed to build dagger internal graph")]
-    Build(#[source] eyre::Error),
-    #[error("failed to parse input type")]
-    Serialize(#[source] eyre::Error),
-    #[error("failed to query dagger engine: {0}")]
-    Query(#[source] dagger_core::graphql_client::GraphQLError),
-    #[error("failed to unpack response")]
-    Unpack(#[source] DaggerUnpackError),
-}
-
-#[derive(Error, Debug)]
-pub enum DaggerUnpackError {
-    #[error("Too many nested objects inside graphql response")]
-    TooManyNestedObjects,
-    #[error("failed to deserialize response")]
-    Deserialize(#[source] serde_json::Error),
-}
--- a/crates/dagger-sdk/src/gen.rs
+++ b/crates/dagger-sdk/src/gen.rs
@ -1,4 +1,3 @@
-use crate::errors::DaggerError;
 use crate::querybuilder::Selection;
 use dagger_core::graphql_client::DynGraphQLClient;
 use derive_builder::Builder;
@ -116,13 +115,13 @@ pub struct PipelineLabel {
 }
 #[derive(Clone)]
 pub struct CacheVolume {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl CacheVolume {
-    pub async fn id(&self) -> Result<CacheId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<CacheId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
@ -130,7 +129,7 @@ impl CacheVolume {
 }
 #[derive(Clone)]
 pub struct Container {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -144,10 +143,6 @@ pub struct ContainerBuildOpts<'a> {
    /// Default: './Dockerfile'.
    #[builder(setter(into, strip_option), default)]
    pub dockerfile: Option<&'a str>,
-    /// Secrets to pass to the build.
-    /// They will be mounted at /run/secrets/[secret-name].
-    #[builder(setter(into, strip_option), default)]
-    pub secrets: Option<Vec<SecretId>>,
    /// Target build stage to build.
    #[builder(setter(into, strip_option), default)]
    pub target: Option<&'a str>,
@ -189,13 +184,6 @@ pub struct ContainerExportOpts {
    pub platform_variants: Option<Vec<ContainerId>>,
 }
 #[derive(Builder, Debug, PartialEq)]
-pub struct ContainerImportOpts<'a> {
-    /// Identifies the tag to import from the archive, if the archive bundles
-    /// multiple tags.
-    #[builder(setter(into, strip_option), default)]
-    pub tag: Option<&'a str>,
-}
-#[derive(Builder, Debug, PartialEq)]
 pub struct ContainerPipelineOpts<'a> {
    /// Pipeline description.
    #[builder(setter(into, strip_option), default)]
@ -225,11 +213,6 @@ pub struct ContainerWithDirectoryOpts<'a> {
    /// Patterns to include in the written directory (e.g., ["*.go", "go.mod", "go.sum"]).
    #[builder(setter(into, strip_option), default)]
    pub include: Option<Vec<&'a str>>,
-    /// A user:group to set for the directory and its contents.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
 }
 #[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithExecOpts<'a> {
@ -250,9 +233,6 @@ pub struct ContainerWithExecOpts<'a> {
    /// Redirect the command's standard output to a file in the container (e.g., "/tmp/stdout").
    #[builder(setter(into, strip_option), default)]
    pub redirect_stdout: Option<&'a str>,
-    /// If the container has an entrypoint, ignore it for args rather than using it to wrap them.
-    #[builder(setter(into, strip_option), default)]
-    pub skip_entrypoint: Option<bool>,
    /// Content to write to the command's standard input before closing (e.g., "Hello world").
    #[builder(setter(into, strip_option), default)]
    pub stdin: Option<&'a str>,
@ -267,27 +247,14 @@ pub struct ContainerWithExposedPortOpts<'a> {
    pub protocol: Option<NetworkProtocol>,
 }
 #[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithFileOpts<'a> {
-    /// A user:group to set for the file.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
+pub struct ContainerWithFileOpts {
    /// Permission given to the copied file (e.g., 0600).
    /// Default: 0644.
    #[builder(setter(into, strip_option), default)]
    pub permissions: Option<isize>,
 }
 #[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithMountedCacheOpts<'a> {
-    /// A user:group to set for the mounted cache directory.
-    /// Note that this changes the ownership of the specified mount along with the
-    /// initial filesystem provided by source (if any). It does not have any effect
-    /// if/when the cache has already been created.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
+pub struct ContainerWithMountedCacheOpts {
    /// Sharing mode of the cache volume.
    #[builder(setter(into, strip_option), default)]
    pub sharing: Option<CacheSharingMode>,
@ -296,53 +263,16 @@ pub struct ContainerWithMountedCacheOpts<'a> {
    pub source: Option<DirectoryId>,
 }
 #[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithMountedDirectoryOpts<'a> {
-    /// A user:group to set for the mounted directory and its contents.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
-}
-#[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithMountedFileOpts<'a> {
-    /// A user or user:group to set for the mounted file.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
-}
-#[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithMountedSecretOpts<'a> {
-    /// A user:group to set for the mounted secret.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
-}
-#[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithNewFileOpts<'a> {
    /// Content of the file to write (e.g., "Hello world!").
    #[builder(setter(into, strip_option), default)]
    pub contents: Option<&'a str>,
-    /// A user:group to set for the file.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
    /// Permission given to the written file (e.g., 0600).
    /// Default: 0644.
    #[builder(setter(into, strip_option), default)]
    pub permissions: Option<isize>,
 }
 #[derive(Builder, Debug, PartialEq)]
-pub struct ContainerWithUnixSocketOpts<'a> {
-    /// A user:group to set for the mounted socket.
-    /// The user and group can either be an ID (1000:1000) or a name (foo:bar).
-    /// If the group is omitted, it defaults to the same as the user.
-    #[builder(setter(into, strip_option), default)]
-    pub owner: Option<&'a str>,
-}
-#[derive(Builder, Debug, PartialEq)]
 pub struct ContainerWithoutExposedPortOpts {
    /// Port protocol to unexpose
    #[builder(setter(into, strip_option), default)]
@ -387,9 +317,6 @@ impl Container {
        if let Some(target) = opts.target {
            query = query.arg("target", target);
        }
-        if let Some(secrets) = opts.secrets {
-            query = query.arg("secrets", secrets);
-        }

        return Container {
            proc: self.proc.clone(),
@ -398,7 +325,7 @@ impl Container {
        };
    }
    /// Retrieves default arguments for future commands.
-    pub async fn default_args(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn default_args(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("defaultArgs");

        query.execute(self.graphql_client.clone()).await
@ -428,7 +355,7 @@ impl Container {
    /// # Arguments
    ///
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn endpoint(&self) -> Result<String, DaggerError> {
+    pub async fn endpoint(&self) -> eyre::Result<String> {
        let query = self.selection.select("endpoint");

        query.execute(self.graphql_client.clone()).await
@ -442,10 +369,7 @@ impl Container {
    /// # Arguments
    ///
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn endpoint_opts<'a>(
-        &self,
-        opts: ContainerEndpointOpts<'a>,
-    ) -> Result<String, DaggerError> {
+    pub async fn endpoint_opts<'a>(&self, opts: ContainerEndpointOpts<'a>) -> eyre::Result<String> {
        let mut query = self.selection.select("endpoint");

        if let Some(port) = opts.port {
@ -458,7 +382,7 @@ impl Container {
        query.execute(self.graphql_client.clone()).await
    }
    /// Retrieves entrypoint to be prepended to the arguments of all commands.
-    pub async fn entrypoint(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn entrypoint(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("entrypoint");

        query.execute(self.graphql_client.clone()).await
@ -468,7 +392,7 @@ impl Container {
    /// # Arguments
    ///
    /// * `name` - The name of the environment variable to retrieve (e.g., "PATH").
-    pub async fn env_variable(&self, name: impl Into<String>) -> Result<String, DaggerError> {
+    pub async fn env_variable(&self, name: impl Into<String>) -> eyre::Result<String> {
        let mut query = self.selection.select("envVariable");

        query = query.arg("name", name.into());
@ -534,8 +458,8 @@ impl Container {
        };
    }
    /// Exit code of the last executed command. Zero means success.
-    /// Will execute default command if none is set, or error if there's no default.
-    pub async fn exit_code(&self) -> Result<isize, DaggerError> {
+    /// Errors if no command has been executed.
+    pub async fn exit_code(&self) -> eyre::Result<isize> {
        let query = self.selection.select("exitCode");

        query.execute(self.graphql_client.clone()).await
@ -549,7 +473,7 @@ impl Container {
    /// * `path` - Host's destination path (e.g., "./tarball").
    /// Path can be relative to the engine's workdir or absolute.
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn export(&self, path: impl Into<String>) -> Result<bool, DaggerError> {
+    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
        let mut query = self.selection.select("export");

        query = query.arg("path", path.into());
@ -570,7 +494,7 @@ impl Container {
        &self,
        path: impl Into<String>,
        opts: ContainerExportOpts,
-    ) -> Result<bool, DaggerError> {
+    ) -> eyre::Result<bool> {
        let mut query = self.selection.select("export");

        query = query.arg("path", path.into());
@ -638,67 +562,25 @@ impl Container {
    }
    /// Retrieves a hostname which can be used by clients to reach this container.
    /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
-    pub async fn hostname(&self) -> Result<String, DaggerError> {
+    pub async fn hostname(&self) -> eyre::Result<String> {
        let query = self.selection.select("hostname");

        query.execute(self.graphql_client.clone()).await
    }
    /// A unique identifier for this container.
-    pub async fn id(&self) -> Result<ContainerId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<ContainerId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
    }
    /// The unique image reference which can only be retrieved immediately after the 'Container.From' call.
-    pub async fn image_ref(&self) -> Result<String, DaggerError> {
+    pub async fn image_ref(&self) -> eyre::Result<String> {
        let query = self.selection.select("imageRef");

        query.execute(self.graphql_client.clone()).await
    }
-    /// Reads the container from an OCI tarball.
-    /// NOTE: this involves unpacking the tarball to an OCI store on the host at
-    /// $XDG_CACHE_DIR/dagger/oci. This directory can be removed whenever you like.
-    ///
-    /// # Arguments
-    ///
-    /// * `source` - File to read the container from.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn import(&self, source: FileId) -> Container {
-        let mut query = self.selection.select("import");
-
-        query = query.arg("source", source);
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
-
-    /// Reads the container from an OCI tarball.
-    /// NOTE: this involves unpacking the tarball to an OCI store on the host at
-    /// $XDG_CACHE_DIR/dagger/oci. This directory can be removed whenever you like.
-    ///
-    /// # Arguments
-    ///
-    /// * `source` - File to read the container from.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn import_opts<'a>(&self, source: FileId, opts: ContainerImportOpts<'a>) -> Container {
-        let mut query = self.selection.select("import");
-
-        query = query.arg("source", source);
-        if let Some(tag) = opts.tag {
-            query = query.arg("tag", tag);
-        }
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
    /// Retrieves the value of the specified label.
-    pub async fn label(&self, name: impl Into<String>) -> Result<String, DaggerError> {
+    pub async fn label(&self, name: impl Into<String>) -> eyre::Result<String> {
        let mut query = self.selection.select("label");

        query = query.arg("name", name.into());
@ -716,7 +598,7 @@ impl Container {
        }];
    }
    /// Retrieves the list of paths where a directory is mounted.
-    pub async fn mounts(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn mounts(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("mounts");

        query.execute(self.graphql_client.clone()).await
@ -767,7 +649,7 @@ impl Container {
        };
    }
    /// The platform this container executes and publishes as.
-    pub async fn platform(&self) -> Result<Platform, DaggerError> {
+    pub async fn platform(&self) -> eyre::Result<Platform> {
        let query = self.selection.select("platform");

        query.execute(self.graphql_client.clone()).await
@ -782,7 +664,7 @@ impl Container {
    ///
    /// Formatted as [host]/[user]/[repo]:[tag] (e.g. "docker.io/dagger/dagger:main").
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn publish(&self, address: impl Into<String>) -> Result<String, DaggerError> {
+    pub async fn publish(&self, address: impl Into<String>) -> eyre::Result<String> {
        let mut query = self.selection.select("publish");

        query = query.arg("address", address.into());
@ -804,7 +686,7 @@ impl Container {
        &self,
        address: impl Into<String>,
        opts: ContainerPublishOpts,
-    ) -> Result<String, DaggerError> {
+    ) -> eyre::Result<String> {
        let mut query = self.selection.select("publish");

        query = query.arg("address", address.into());
@ -825,21 +707,21 @@ impl Container {
        };
    }
    /// The error stream of the last executed command.
-    /// Will execute default command if none is set, or error if there's no default.
-    pub async fn stderr(&self) -> Result<String, DaggerError> {
+    /// Errors if no command has been executed.
+    pub async fn stderr(&self) -> eyre::Result<String> {
        let query = self.selection.select("stderr");

        query.execute(self.graphql_client.clone()).await
    }
    /// The output stream of the last executed command.
-    /// Will execute default command if none is set, or error if there's no default.
-    pub async fn stdout(&self) -> Result<String, DaggerError> {
+    /// Errors if no command has been executed.
+    pub async fn stdout(&self) -> eyre::Result<String> {
        let query = self.selection.select("stdout");

        query.execute(self.graphql_client.clone()).await
    }
    /// Retrieves the user to be set for all commands.
-    pub async fn user(&self) -> Result<String, DaggerError> {
+    pub async fn user(&self) -> eyre::Result<String> {
        let query = self.selection.select("user");

        query.execute(self.graphql_client.clone()).await
@ -920,9 +802,6 @@ impl Container {
        if let Some(include) = opts.include {
            query = query.arg("include", include);
        }
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }

        return Container {
            proc: self.proc.clone(),
@ -976,8 +855,6 @@ impl Container {
    /// # Arguments
    ///
    /// * `args` - Command to run instead of the container's default command (e.g., ["run", "main.go"]).
-    ///
-    /// If empty, the container's default command is used.
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_exec(&self, args: Vec<impl Into<String>>) -> Container {
        let mut query = self.selection.select("withExec");
@ -999,8 +876,6 @@ impl Container {
    /// # Arguments
    ///
    /// * `args` - Command to run instead of the container's default command (e.g., ["run", "main.go"]).
-    ///
-    /// If empty, the container's default command is used.
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_exec_opts<'a>(
        &self,
@ -1013,9 +888,6 @@ impl Container {
            "args",
            args.into_iter().map(|i| i.into()).collect::<Vec<String>>(),
        );
-        if let Some(skip_entrypoint) = opts.skip_entrypoint {
-            query = query.arg("skipEntrypoint", skip_entrypoint);
-        }
        if let Some(stdin) = opts.stdin {
            query = query.arg("stdin", stdin);
        }
@ -1133,11 +1005,11 @@ impl Container {
    /// * `path` - Location of the copied file (e.g., "/tmp/file.txt").
    /// * `source` - Identifier of the file to copy.
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_file_opts<'a>(
+    pub fn with_file_opts(
        &self,
        path: impl Into<String>,
        source: FileId,
-        opts: ContainerWithFileOpts<'a>,
+        opts: ContainerWithFileOpts,
    ) -> Container {
        let mut query = self.selection.select("withFile");

@ -1146,9 +1018,6 @@ impl Container {
        if let Some(permissions) = opts.permissions {
            query = query.arg("permissions", permissions);
        }
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }

        return Container {
            proc: self.proc.clone(),
@ -1201,11 +1070,11 @@ impl Container {
    /// * `path` - Location of the cache directory (e.g., "/cache/node_modules").
    /// * `cache` - Identifier of the cache volume to mount.
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_mounted_cache_opts<'a>(
+    pub fn with_mounted_cache_opts(
        &self,
        path: impl Into<String>,
        cache: CacheId,
-        opts: ContainerWithMountedCacheOpts<'a>,
+        opts: ContainerWithMountedCacheOpts,
    ) -> Container {
        let mut query = self.selection.select("withMountedCache");

@ -1217,9 +1086,6 @@ impl Container {
        if let Some(sharing) = opts.sharing {
            query = query.arg_enum("sharing", sharing);
        }
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }

        return Container {
            proc: self.proc.clone(),
@ -1233,7 +1099,6 @@ impl Container {
    ///
    /// * `path` - Location of the mounted directory (e.g., "/mnt/directory").
    /// * `source` - Identifier of the mounted directory.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_mounted_directory(
        &self,
        path: impl Into<String>,
@ -1250,41 +1115,12 @@ impl Container {
            graphql_client: self.graphql_client.clone(),
        };
    }
-
-    /// Retrieves this container plus a directory mounted at the given path.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Location of the mounted directory (e.g., "/mnt/directory").
-    /// * `source` - Identifier of the mounted directory.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_mounted_directory_opts<'a>(
-        &self,
-        path: impl Into<String>,
-        source: DirectoryId,
-        opts: ContainerWithMountedDirectoryOpts<'a>,
-    ) -> Container {
-        let mut query = self.selection.select("withMountedDirectory");
-
-        query = query.arg("path", path.into());
-        query = query.arg("source", source);
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
    /// Retrieves this container plus a file mounted at the given path.
    ///
    /// # Arguments
    ///
    /// * `path` - Location of the mounted file (e.g., "/tmp/file.txt").
    /// * `source` - Identifier of the mounted file.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_mounted_file(&self, path: impl Into<String>, source: FileId) -> Container {
        let mut query = self.selection.select("withMountedFile");

@ -1297,41 +1133,12 @@ impl Container {
            graphql_client: self.graphql_client.clone(),
        };
    }
-
-    /// Retrieves this container plus a file mounted at the given path.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Location of the mounted file (e.g., "/tmp/file.txt").
-    /// * `source` - Identifier of the mounted file.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_mounted_file_opts<'a>(
-        &self,
-        path: impl Into<String>,
-        source: FileId,
-        opts: ContainerWithMountedFileOpts<'a>,
-    ) -> Container {
-        let mut query = self.selection.select("withMountedFile");
-
-        query = query.arg("path", path.into());
-        query = query.arg("source", source);
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
    /// Retrieves this container plus a secret mounted into a file at the given path.
    ///
    /// # Arguments
    ///
    /// * `path` - Location of the secret file (e.g., "/tmp/secret.txt").
    /// * `source` - Identifier of the secret to mount.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_mounted_secret(&self, path: impl Into<String>, source: SecretId) -> Container {
        let mut query = self.selection.select("withMountedSecret");

@ -1344,34 +1151,6 @@ impl Container {
            graphql_client: self.graphql_client.clone(),
        };
    }
-
-    /// Retrieves this container plus a secret mounted into a file at the given path.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Location of the secret file (e.g., "/tmp/secret.txt").
-    /// * `source` - Identifier of the secret to mount.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_mounted_secret_opts<'a>(
-        &self,
-        path: impl Into<String>,
-        source: SecretId,
-        opts: ContainerWithMountedSecretOpts<'a>,
-    ) -> Container {
-        let mut query = self.selection.select("withMountedSecret");
-
-        query = query.arg("path", path.into());
-        query = query.arg("source", source);
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
    /// Retrieves this container plus a temporary directory mounted at the given path.
    ///
    /// # Arguments
@ -1426,9 +1205,6 @@ impl Container {
        if let Some(permissions) = opts.permissions {
            query = query.arg("permissions", permissions);
        }
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }

        return Container {
            proc: self.proc.clone(),
@ -1492,9 +1268,7 @@ impl Container {
            graphql_client: self.graphql_client.clone(),
        };
    }
-    /// Establish a runtime dependency on a service.
-    /// The service will be started automatically when needed and detached when it is
-    /// no longer needed, executing the default command if none is set.
+    /// Establish a runtime dependency on a service. The service will be started automatically when needed and detached when it is no longer needed.
    /// The service will be reachable from the container via the provided hostname alias.
    /// The service dependency will also convey to any files or directories produced by the container.
    /// Currently experimental; set _EXPERIMENTAL_DAGGER_SERVICES_DNS=0 to disable.
@ -1525,7 +1299,6 @@ impl Container {
    ///
    /// * `path` - Location of the forwarded Unix socket (e.g., "/tmp/socket").
    /// * `source` - Identifier of the socket to forward.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
    pub fn with_unix_socket(&self, path: impl Into<String>, source: SocketId) -> Container {
        let mut query = self.selection.select("withUnixSocket");

@ -1538,34 +1311,6 @@ impl Container {
            graphql_client: self.graphql_client.clone(),
        };
    }
-
-    /// Retrieves this container plus a socket forwarded to the given Unix socket path.
-    ///
-    /// # Arguments
-    ///
-    /// * `path` - Location of the forwarded Unix socket (e.g., "/tmp/socket").
-    /// * `source` - Identifier of the socket to forward.
-    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub fn with_unix_socket_opts<'a>(
-        &self,
-        path: impl Into<String>,
-        source: SocketId,
-        opts: ContainerWithUnixSocketOpts<'a>,
-    ) -> Container {
-        let mut query = self.selection.select("withUnixSocket");
-
-        query = query.arg("path", path.into());
-        query = query.arg("source", source);
-        if let Some(owner) = opts.owner {
-            query = query.arg("owner", owner);
-        }
-
-        return Container {
-            proc: self.proc.clone(),
-            selection: query,
-            graphql_client: self.graphql_client.clone(),
-        };
-    }
    /// Retrieves this container with a different command user.
    ///
    /// # Arguments
@ -1724,7 +1469,7 @@ impl Container {
        };
    }
    /// Retrieves the working directory for all commands.
-    pub async fn workdir(&self) -> Result<String, DaggerError> {
+    pub async fn workdir(&self) -> eyre::Result<String> {
        let query = self.selection.select("workdir");

        query.execute(self.graphql_client.clone()).await
@ -1732,7 +1477,7 @@ impl Container {
 }
 #[derive(Clone)]
 pub struct Directory {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -1749,10 +1494,6 @@ pub struct DirectoryDockerBuildOpts<'a> {
    /// The platform to build.
    #[builder(setter(into, strip_option), default)]
    pub platform: Option<Platform>,
-    /// Secrets to pass to the build.
-    /// They will be mounted at /run/secrets/[secret-name].
-    #[builder(setter(into, strip_option), default)]
-    pub secrets: Option<Vec<SecretId>>,
    /// Target build stage to build.
    #[builder(setter(into, strip_option), default)]
    pub target: Option<&'a str>,
@ -1871,9 +1612,6 @@ impl Directory {
        if let Some(target) = opts.target {
            query = query.arg("target", target);
        }
-        if let Some(secrets) = opts.secrets {
-            query = query.arg("secrets", secrets);
-        }

        return Container {
            proc: self.proc.clone(),
@ -1886,7 +1624,7 @@ impl Directory {
    /// # Arguments
    ///
    /// * `opt` - optional argument, see inner type for documentation, use <func>_opts to use
-    pub async fn entries(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn entries(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("entries");

        query.execute(self.graphql_client.clone()).await
@ -1900,7 +1638,7 @@ impl Directory {
    pub async fn entries_opts<'a>(
        &self,
        opts: DirectoryEntriesOpts<'a>,
-    ) -> Result<Vec<String>, DaggerError> {
+    ) -> eyre::Result<Vec<String>> {
        let mut query = self.selection.select("entries");

        if let Some(path) = opts.path {
@ -1914,7 +1652,7 @@ impl Directory {
    /// # Arguments
    ///
    /// * `path` - Location of the copied directory (e.g., "logs/").
-    pub async fn export(&self, path: impl Into<String>) -> Result<bool, DaggerError> {
+    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
        let mut query = self.selection.select("export");

        query = query.arg("path", path.into());
@ -1938,7 +1676,7 @@ impl Directory {
        };
    }
    /// The content-addressed identifier of the directory.
-    pub async fn id(&self) -> Result<DirectoryId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<DirectoryId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
@ -2239,20 +1977,20 @@ impl Directory {
 }
 #[derive(Clone)]
 pub struct EnvVariable {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl EnvVariable {
    /// The environment variable name.
-    pub async fn name(&self) -> Result<String, DaggerError> {
+    pub async fn name(&self) -> eyre::Result<String> {
        let query = self.selection.select("name");

        query.execute(self.graphql_client.clone()).await
    }
    /// The environment variable value.
-    pub async fn value(&self) -> Result<String, DaggerError> {
+    pub async fn value(&self) -> eyre::Result<String> {
        let query = self.selection.select("value");

        query.execute(self.graphql_client.clone()).await
@ -2260,14 +1998,14 @@ impl EnvVariable {
 }
 #[derive(Clone)]
 pub struct File {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl File {
    /// Retrieves the contents of the file.
-    pub async fn contents(&self) -> Result<String, DaggerError> {
+    pub async fn contents(&self) -> eyre::Result<String> {
        let query = self.selection.select("contents");

        query.execute(self.graphql_client.clone()).await
@ -2277,7 +2015,7 @@ impl File {
    /// # Arguments
    ///
    /// * `path` - Location of the written directory (e.g., "output.txt").
-    pub async fn export(&self, path: impl Into<String>) -> Result<bool, DaggerError> {
+    pub async fn export(&self, path: impl Into<String>) -> eyre::Result<bool> {
        let mut query = self.selection.select("export");

        query = query.arg("path", path.into());
@ -2285,7 +2023,7 @@ impl File {
        query.execute(self.graphql_client.clone()).await
    }
    /// Retrieves the content-addressed identifier of the file.
-    pub async fn id(&self) -> Result<FileId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<FileId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
@ -2301,7 +2039,7 @@ impl File {
        };
    }
    /// Gets the size of the file, in bytes.
-    pub async fn size(&self) -> Result<isize, DaggerError> {
+    pub async fn size(&self) -> eyre::Result<isize> {
        let query = self.selection.select("size");

        query.execute(self.graphql_client.clone()).await
@ -2327,7 +2065,7 @@ impl File {
 }
 #[derive(Clone)]
 pub struct GitRef {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2342,7 +2080,7 @@ pub struct GitRefTreeOpts<'a> {

 impl GitRef {
    /// The digest of the current value of this ref.
-    pub async fn digest(&self) -> Result<String, DaggerError> {
+    pub async fn digest(&self) -> eyre::Result<String> {
        let query = self.selection.select("digest");

        query.execute(self.graphql_client.clone()).await
@ -2386,7 +2124,7 @@ impl GitRef {
 }
 #[derive(Clone)]
 pub struct GitRepository {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2409,7 +2147,7 @@ impl GitRepository {
        };
    }
    /// Lists of branches on the repository.
-    pub async fn branches(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn branches(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("branches");

        query.execute(self.graphql_client.clone()).await
@ -2447,7 +2185,7 @@ impl GitRepository {
        };
    }
    /// Lists of tags on the repository.
-    pub async fn tags(&self) -> Result<Vec<String>, DaggerError> {
+    pub async fn tags(&self) -> eyre::Result<Vec<String>> {
        let query = self.selection.select("tags");

        query.execute(self.graphql_client.clone()).await
@ -2455,7 +2193,7 @@ impl GitRepository {
 }
 #[derive(Clone)]
 pub struct Host {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2596,7 +2334,7 @@ impl Host {
 }
 #[derive(Clone)]
 pub struct HostVariable {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2613,7 +2351,7 @@ impl HostVariable {
        };
    }
    /// The value of this variable.
-    pub async fn value(&self) -> Result<String, DaggerError> {
+    pub async fn value(&self) -> eyre::Result<String> {
        let query = self.selection.select("value");

        query.execute(self.graphql_client.clone()).await
@ -2621,20 +2359,20 @@ impl HostVariable {
 }
 #[derive(Clone)]
 pub struct Label {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl Label {
    /// The label name.
-    pub async fn name(&self) -> Result<String, DaggerError> {
+    pub async fn name(&self) -> eyre::Result<String> {
        let query = self.selection.select("name");

        query.execute(self.graphql_client.clone()).await
    }
    /// The label value.
-    pub async fn value(&self) -> Result<String, DaggerError> {
+    pub async fn value(&self) -> eyre::Result<String> {
        let query = self.selection.select("value");

        query.execute(self.graphql_client.clone()).await
@ -2642,26 +2380,26 @@ impl Label {
 }
 #[derive(Clone)]
 pub struct Port {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl Port {
    /// The port description.
-    pub async fn description(&self) -> Result<String, DaggerError> {
+    pub async fn description(&self) -> eyre::Result<String> {
        let query = self.selection.select("description");

        query.execute(self.graphql_client.clone()).await
    }
    /// The port number.
-    pub async fn port(&self) -> Result<isize, DaggerError> {
+    pub async fn port(&self) -> eyre::Result<isize> {
        let query = self.selection.select("port");

        query.execute(self.graphql_client.clone()).await
    }
    /// The transport layer network protocol.
-    pub async fn protocol(&self) -> Result<NetworkProtocol, DaggerError> {
+    pub async fn protocol(&self) -> eyre::Result<NetworkProtocol> {
        let query = self.selection.select("protocol");

        query.execute(self.graphql_client.clone()).await
@ -2669,7 +2407,7 @@ impl Port {
 }
 #[derive(Clone)]
 pub struct Project {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2696,25 +2434,25 @@ impl Project {
        };
    }
    /// install the project's schema
-    pub async fn install(&self) -> Result<bool, DaggerError> {
+    pub async fn install(&self) -> eyre::Result<bool> {
        let query = self.selection.select("install");

        query.execute(self.graphql_client.clone()).await
    }
    /// name of the project
-    pub async fn name(&self) -> Result<String, DaggerError> {
+    pub async fn name(&self) -> eyre::Result<String> {
        let query = self.selection.select("name");

        query.execute(self.graphql_client.clone()).await
    }
    /// schema provided by the project
-    pub async fn schema(&self) -> Result<String, DaggerError> {
+    pub async fn schema(&self) -> eyre::Result<String> {
        let query = self.selection.select("schema");

        query.execute(self.graphql_client.clone()).await
    }
    /// sdk used to generate code for and/or execute this project
-    pub async fn sdk(&self) -> Result<String, DaggerError> {
+    pub async fn sdk(&self) -> eyre::Result<String> {
        let query = self.selection.select("sdk");

        query.execute(self.graphql_client.clone()).await
@ -2722,7 +2460,7 @@ impl Project {
 }
 #[derive(Clone)]
 pub struct Query {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }
@ -2829,7 +2567,7 @@ impl Query {
        };
    }
    /// The default platform of the builder.
-    pub async fn default_platform(&self) -> Result<Platform, DaggerError> {
+    pub async fn default_platform(&self) -> eyre::Result<Platform> {
        let query = self.selection.select("defaultPlatform");

        query.execute(self.graphql_client.clone()).await
@ -3091,20 +2829,20 @@ impl Query {
 }
 #[derive(Clone)]
 pub struct Secret {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl Secret {
    /// The identifier for this secret.
-    pub async fn id(&self) -> Result<SecretId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<SecretId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
    }
    /// The value of this secret.
-    pub async fn plaintext(&self) -> Result<String, DaggerError> {
+    pub async fn plaintext(&self) -> eyre::Result<String> {
        let query = self.selection.select("plaintext");

        query.execute(self.graphql_client.clone()).await
@ -3112,14 +2850,14 @@ impl Secret {
 }
 #[derive(Clone)]
 pub struct Socket {
-    pub proc: Option<Arc<Child>>,
+    pub proc: Arc<Child>,
    pub selection: Selection,
    pub graphql_client: DynGraphQLClient,
 }

 impl Socket {
    /// The content-addressed identifier of the socket.
-    pub async fn id(&self) -> Result<SocketId, DaggerError> {
+    pub async fn id(&self) -> eyre::Result<SocketId> {
        let query = self.selection.select("id");

        query.execute(self.graphql_client.clone()).await
--- a/crates/dagger-sdk/src/lib.rs
+++ b/crates/dagger-sdk/src/lib.rs
@ -1,7 +1,6 @@
 #![deny(warnings)]

 mod client;
-pub mod errors;
 mod gen;
 pub mod logging;
 mod querybuilder;
--- a/crates/dagger-sdk/src/querybuilder.rs
+++ b/crates/dagger-sdk/src/querybuilder.rs
@ -1,10 +1,9 @@
 use std::{collections::HashMap, ops::Add, sync::Arc};

 use dagger_core::graphql_client::DynGraphQLClient;
+use eyre::Context;
 use serde::{Deserialize, Serialize};

-use crate::errors::{DaggerError, DaggerUnpackError};
-
 pub fn query() -> Selection {
    Selection::default()
 }
@ -93,7 +92,7 @@ impl Selection {
        s
    }

-    pub fn build(&self) -> Result<String, DaggerError> {
+    pub fn build(&self) -> eyre::Result<String> {
        let mut fields = vec!["query".to_string()];

        for sel in self.path() {
@ -118,7 +117,7 @@ impl Selection {
        Ok(fields.join("{") + &"}".repeat(fields.len() - 1))
    }

-    pub async fn execute<D>(&self, gql_client: DynGraphQLClient) -> Result<D, DaggerError>
+    pub async fn execute<D>(&self, gql_client: DynGraphQLClient) -> eyre::Result<D>
    where
        D: for<'de> Deserialize<'de>,
    {
@ -128,7 +127,7 @@ impl Selection {

        let resp: Option<serde_json::Value> = match gql_client.query(&query).await {
            Ok(r) => r,
-            Err(e) => return Err(DaggerError::Query(e)),
+            Err(e) => eyre::bail!(e),
        };

        let resp: Option<D> = self.unpack_resp(resp)?;
@ -152,10 +151,7 @@ impl Selection {
        selections
    }

-    pub(crate) fn unpack_resp<D>(
-        &self,
-        resp: Option<serde_json::Value>,
-    ) -> Result<Option<D>, DaggerError>
+    pub(crate) fn unpack_resp<D>(&self, resp: Option<serde_json::Value>) -> eyre::Result<Option<D>>
    where
        D: for<'de> Deserialize<'de>,
    {
@ -165,23 +161,21 @@ impl Selection {
        }
    }

-    fn unpack_resp_value<D>(&self, r: serde_json::Value) -> Result<D, DaggerError>
+    fn unpack_resp_value<D>(&self, r: serde_json::Value) -> eyre::Result<D>
    where
        D: for<'de> Deserialize<'de>,
    {
        if let Some(o) = r.as_object() {
            let keys = o.keys();
            if keys.len() != 1 {
-                return Err(DaggerError::Unpack(DaggerUnpackError::TooManyNestedObjects));
+                eyre::bail!("too many nested objects inside graphql response")
            }

            let first = keys.into_iter().next().unwrap();
            return self.unpack_resp_value(o.get(first).unwrap().clone());
        }

-        serde_json::from_value::<D>(r)
-            .map_err(DaggerUnpackError::Deserialize)
-            .map_err(DaggerError::Unpack)
+        serde_json::from_value::<D>(r).context("could not deserialize response")
    }
 }

--- a/crates/dagger-sdk/tests/mod.rs
+++ b/crates/dagger-sdk/tests/mod.rs
@ -111,9 +111,9 @@ async fn test_err_message() {
    assert_eq!(alpine.is_err(), true);
    let err = alpine.expect_err("Tests expect err");

-    let error_msg = r#"failed to query dagger engine: domain error:
-Look at json field for more details
-pull access denied, repository does not exist or may require authorization: server message: insufficient_scope: authorization failed
+    let error_msg = r#"
+GQLClient Error: Look at json field for more details
+Message: pull access denied, repository does not exist or may require authorization: server message: insufficient_scope: authorization failed
 "#;

    assert_eq!(err.to_string().as_str(), error_msg);