@spec address(t(), String.t()) :: Dagger.Address.t()

Resolve external references only.

@spec blob(t(), String.t(), Dagger.Bytes.t(), [{:permissions, integer() | nil}]) ::
  Dagger.File.t()

Creates a file from arbitrary binary contents.

@spec cache_volume(t(), String.t(),
  source: Dagger.Directory.t() | nil,
  sharing: Dagger.CacheSharingMode.t() | nil,
  owner: String.t() | nil
) :: Dagger.CacheVolume.t()

Constructs a cache volume for a given cache key.

@spec changeset(t()) :: Dagger.Changeset.t()

Creates an empty changeset

@spec cloud(t()) :: Dagger.Cloud.t()

Dagger Cloud configuration and state

@spec container(t(), [{:platform, Dagger.Platform.t() | nil}]) :: Dagger.Container.t()

Creates a scratch container, with no image or metadata.

To pull an image, follow up with the "from" function.

@spec current_function_call(t()) :: Dagger.FunctionCall.t()

The FunctionCall context that the SDK caller is currently executing in.

If the caller is not currently executing in a function, this will return an error.

@spec current_module(t()) :: Dagger.CurrentModule.t()

The module currently being served in the session, if any.

@spec current_node(t()) :: Dagger.Node.t()

The object that received the current module function call, as a Node. Errors when there is no current call, or the call is top-level (e.g. a module constructor).

@spec current_timestamp(t()) :: {:ok, String.t()} | {:error, term()}

The current UTC time in RFC3339 format. Never cached.

@spec current_type_defs(t(),
  return_all_types: boolean() | nil,
  hide_core: boolean() | nil
) ::
  {:ok, [Dagger.TypeDef.t()]} | {:error, term()}

The TypeDef representations of the objects currently being served in the session.

@spec current_workspace(t()) :: Dagger.Workspace.t()

Detect and return the current workspace.

@spec default_platform(t()) :: {:ok, Dagger.Platform.t()} | {:error, term()}

The default platform of the engine.

@spec directory(t()) :: Dagger.Directory.t()

Creates an empty directory.

@spec engine(t()) :: Dagger.Engine.t()

The Dagger engine container configuration and state

@spec engine_volume(t(), String.t(), [{:subdir, String.t() | nil}]) ::
  Dagger.Volume.t()

Constructs an engine-managed volume backed by operator-provided storage beneath the configured engine state root.

@spec env_file(t(), [{:expand, boolean() | nil}]) :: Dagger.EnvFile.t()

Initialize an environment file

@spec error(t(), String.t()) :: Dagger.Error.t()

Create a new error.

@spec file(t(), String.t(), String.t(), [{:permissions, integer() | nil}]) ::
  Dagger.File.t()

Creates a file with the specified contents.

@spec function(t(), String.t(), Dagger.TypeDef.t()) :: Dagger.Function.t()

Creates a function.

@spec generated_code(t(), Dagger.Directory.t()) :: Dagger.GeneratedCode.t()

Create a code generation result, given a directory containing the generated code.

@spec git(t(), String.t(),
  keep_git_dir: boolean() | nil,
  ssh_known_hosts: String.t() | nil,
  ssh_auth_socket: Dagger.Socket.t() | nil,
  http_auth_username: String.t() | nil,
  http_auth_token: Dagger.Secret.t() | nil,
  http_auth_header: Dagger.Secret.t() | nil,
  experimental_service_host: Dagger.Service.t() | nil
) :: Dagger.GitRepository.t()

Queries a Git repository.

@spec host(t()) :: Dagger.Host.t()

Queries the host environment.

@spec http(t(), String.t(),
  name: String.t() | nil,
  permissions: integer() | nil,
  checksum: String.t() | nil,
  auth_header: Dagger.Secret.t() | nil,
  experimental_service_host: Dagger.Service.t() | nil
) :: Dagger.File.t()

Returns a file containing an http remote url content.

@spec id(t()) :: {:ok, String.t()} | {:error, term()}

A unique identifier for this Query.

@spec json(t()) :: Dagger.JSONValue.t()

Initialize a JSON value

@spec llm(t(), model: String.t() | nil, provider: String.t() | nil) :: Dagger.LLM.t()

Initialize a new LLM conversation.

@spec llm_content(t()) :: Dagger.LLMContent.t()

Start an empty run of text and media content, independent of any conversation.

Add blocks with withText, withFile, and withData. A function exposed as an LLM tool can return the content to give the model text and media as the tool's result, e.g. a caption and a screenshot for the model to look at.

@spec module(t()) :: Dagger.Module.t()

Create a new module.

@spec module_source(t(), String.t(),
  version: String.t() | nil,
  ref_pin: String.t() | nil,
  disable_find_up: boolean() | nil,
  allow_not_exists: boolean() | nil,
  require_kind: Dagger.ModuleSourceKind.t() | nil
) :: Dagger.ModuleSource.t()

Create a new module source instance from a source ref string

@spec node(t(), String.t()) :: {:ok, Dagger.Node.t() | nil} | {:error, term()}

Load any object by its ID.

@spec schema(t(), Dagger.JSON.t()) :: Dagger.Schema.t()

Load a GraphQL introspection schema for merging.

@spec secret(t(), String.t(), [{:cache_key, String.t() | nil}]) :: Dagger.Secret.t()

Creates a new secret.

@spec serve_module(t(), String.t(), [{:ref_pin, String.t() | nil}]) ::
  :ok | {:error, term()}

Load the module at the given address and serve its API in the current session.

A local address resolves against the caller's workspace, so a generated client can serve the module it is bound to without reaching for the workspace itself.

@spec set_secret(t(), String.t(), String.t()) :: Dagger.Secret.t()

Sets a secret given a user defined name to its plaintext and returns the secret.

The plaintext value is limited to a size of 128000 bytes.

@spec set_session_title(t(), String.t()) :: :ok | {:error, term()}

Name the current session.

The title renames the session wherever its telemetry is shown (the calling client's primary span, e.g. the CLI's command span) and labels its engine archive, as listed by dagger agent --resume. The latest title wins. Only the session's main client may set it.

@spec source_map(t(), String.t(), integer(), integer()) :: Dagger.SourceMap.t()

Creates source map metadata.

@spec sshfs_volume(t(), String.t(), Dagger.Secret.t(),
  known_hosts: Dagger.Secret.t() | nil,
  cache_key: String.t() | nil,
  insecure_skip_host_key_check: boolean() | nil,
  experimental_service_host: Dagger.Service.t() | nil
) :: Dagger.Volume.t()

Constructs an SSHFS volume.

@spec type_def(t()) :: Dagger.TypeDef.t()

Create a new TypeDef.

@spec version(t()) :: {:ok, String.t()} | {:error, term()}

Get the current Dagger Engine version.