> For the complete documentation index, see [llms.txt](https://docs.talus.network/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.talus.network/reference/sdk/actions-tap.md).

# Talus Agent Package (TAP) Actions

**Audience:** Nexus SDK integrators (Rust).

**Area:** Talus Agent Package (TAP) actions.

**Generated from:** Nexus SDK TAP API at release `v2.1.1` commit `08bfe76e726922ce512d623fbc1d2e1bd786bcd4`; the generated inventory is preserved and 2.1.1 transfer/binding helpers are source-verified.

### TAP actions

The inventory below is the public TAP surface in source declaration order. Historical payment-ticket and Protocol compatibility APIs are not part of the documented TAP declarations. `TapActions::refill_execution_payment` and `TapActions::refill_execution_payment_from_agent_vault` compose the selected top-up with `emit_payment_ready_walk_requests`, so the submitted transaction requests every active walk whose payment is ready. They do not settle a committed result that is already `PendingSettlement`; that walk still requires its eligible settlement transition.

`TapActions::bind_agent_skill` transfers the newly created Agent to the signer after registering its first skill so the PTB does not leave an unused value. Preserve the returned Agent and skill IDs and verify the binding transaction effects before scheduling work.

### Source-derived public API inventory

#### `TapActions`

```rust
pub struct TapActions {
    pub(super) client: NexusClient,
}
```

#### `CreateAgentResult`

```rust
pub struct CreateAgentResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub agent_id: AgentId,
    pub agent_object: sui::types::ObjectReference,
}
```

#### `RegisterSkillResult`

```rust
pub struct RegisterSkillResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub agent_id: AgentId,
    pub skill_id: SkillId,
}
```

#### `UpdateSkillResult`

```rust
pub struct UpdateSkillResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub agent_id: AgentId,
    pub skill_id: SkillId,
    pub current_interface_revision: InterfaceVersion,
    pub dag_binding: crate::move_bindings::interface::agent::SkillDagBinding,
    pub requirements: SkillRequirement,
}
```

#### `GetSkillRequirementResult`

```rust
pub struct GetSkillRequirementResult {
    pub agent_id: AgentId,
    pub skill_id: SkillId,
    pub active_skill_revision_key: SkillRevisionLookupKey,
    pub requirements: SkillRequirement,
}
```

#### `TapPackagePublishResult`

```rust
pub struct TapPackagePublishResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub package_id: sui::types::Address,
}
```

#### `PublishSkillResult`

```rust
pub struct PublishSkillResult {
    pub tap_package: TapPackagePublishResult,
    pub dag: crate::nexus::workflow::PublishResult,
    pub artifact: TapPublishArtifact,
}
```

#### `BindAgentSkillParams`

```rust
pub struct BindAgentSkillParams {
    pub artifact: TapPublishArtifact,
}
```

#### `BindAgentSkillResult`

```rust
pub struct BindAgentSkillResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub agent_id: AgentId,
    pub agent_object: sui::types::ObjectReference,
    pub skill_id: SkillId,
}
```

#### `WaitForPaymentResult`

```rust
pub struct WaitForPaymentResult {
    pub payment_id: sui::types::Address,
    pub payment: ExecutionPaymentInnerV1,
    pub terminal: bool,
    pub elapsed_ms: u64,
    pub timed_out: bool,
}
```

#### `DepositAgentVaultParams`

```rust
pub struct DepositAgentVaultParams {
    pub agent_id: AgentId,
    pub amount: u64,
}
```

#### `DepositAgentVaultResult`

```rust
pub struct DepositAgentVaultResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub agent_id: AgentId,
    pub amount: u64,
}
```

#### `RefillExecutionPaymentParams`

```rust
pub struct RefillExecutionPaymentParams {
    /// The shared `DAGExecution` object whose live TAP payment should receive
    /// additional funds.
    pub execution_id: sui::types::Address,
    /// MIST amount split from the transaction gas coin and moved into the
    /// execution payment.
    pub amount: u64,
}
```

#### `RefillExecutionPaymentFromAgentVaultParams`

```rust
pub struct RefillExecutionPaymentFromAgentVaultParams {
    /// The shared `DAGExecution` object whose live TAP payment should receive
    /// additional funds.
    pub execution_id: sui::types::Address,
    /// Agent object whose vault is the refill source.
    pub agent_id: AgentId,
    /// MIST amount withdrawn from the agent vault.
    pub amount: u64,
}
```

#### `RefillExecutionPaymentResult`

```rust
pub struct RefillExecutionPaymentResult {
    pub tx_digest: sui::types::Digest,
    pub tx_checkpoint: u64,
    pub execution_id: sui::types::Address,
    pub agent_id: Option<AgentId>,
    pub amount: u64,
}
```

#### `payment_is_terminal`

```rust
pub fn payment_is_terminal(payment: &ExecutionPaymentInnerV1) -> bool {
```

#### `TapActions::publish_tap_package`

```rust
pub async fn publish_tap_package(
        &self,
        package: MovePackageArtifact,
    ) -> Result<TapPackagePublishResult, NexusError> {
```

#### `TapActions::publish_skill`

```rust
pub async fn publish_skill(
        &self,
        workflow_package: sui::types::Address,
        config: &SkillConfig,
        dag: DagSpec,
        package: MovePackageArtifact,
    ) -> Result<PublishSkillResult, NexusError> {
```

#### `TapActions::create_agent`

```rust
pub async fn create_agent(&self) -> Result<CreateAgentResult, NexusError> {
```

#### `TapActions::register_skill`

```rust
pub async fn register_skill(
        &self,
        agent_id: AgentId,
        artifact: &TapPublishArtifact,
    ) -> Result<RegisterSkillResult, NexusError> {
```

#### `TapActions::get_skill_requirements`

```rust
pub async fn get_skill_requirements(
        &self,
        agent_id: AgentId,
        skill_id: SkillId,
    ) -> Result<GetSkillRequirementResult, NexusError> {
```

#### `TapActions::update_skill_from_artifact`

```rust
pub async fn update_skill_from_artifact(
        &self,
        agent_id: AgentId,
        skill_id: SkillId,
        artifact: &TapPublishArtifact,
    ) -> Result<UpdateSkillResult, NexusError> {
```

#### `TapActions::deposit_agent_payment_vault`

```rust
pub async fn deposit_agent_payment_vault(
        &self,
        params: DepositAgentVaultParams,
    ) -> Result<DepositAgentVaultResult, NexusError> {
```

#### `TapActions::refill_execution_payment`

```rust
pub async fn refill_execution_payment(
        &self,
        params: RefillExecutionPaymentParams,
    ) -> Result<RefillExecutionPaymentResult, NexusError> {
```

#### `TapActions::refill_execution_payment_from_agent_vault`

```rust
pub async fn refill_execution_payment_from_agent_vault(
        &self,
        params: RefillExecutionPaymentFromAgentVaultParams,
    ) -> Result<RefillExecutionPaymentResult, NexusError> {
```

#### `TapActions::bind_agent_skill`

```rust
pub async fn bind_agent_skill(
        &self,
        params: BindAgentSkillParams,
    ) -> Result<BindAgentSkillResult, NexusError> {
```

#### `TapActions::wait_for_payment_settled`

```rust
pub async fn wait_for_payment_settled(
        &self,
        payment_id: sui::types::Address,
        timeout: Duration,
        poll_interval: Duration,
    ) -> Result<WaitForPaymentResult, NexusError> {
```

#### `fetch_agent_registry`

```rust
pub async fn fetch_agent_registry(
    client: &NexusClient,
    context: &NexusContext,
) -> anyhow::Result<Response<AgentRegistrySnapshot>> {
```

#### `fetch_skill_revision`

```rust
pub async fn fetch_skill_revision(
    client: &NexusClient,
    context: &NexusContext,
    agent_id: AgentId,
    skill_id: SkillId,
    interface_revision: InterfaceVersion,
) -> anyhow::Result<Response<SkillRevisionContext>> {
```

#### `fetch_active_tap_skill_revision`

```rust
pub async fn fetch_active_tap_skill_revision(
    client: &NexusClient,
    context: &NexusContext,
    agent_id: AgentId,
    skill_id: SkillId,
) -> anyhow::Result<Response<SkillRevisionContext>> {
```

#### `fetch_configured_agent_registry`

```rust
pub async fn fetch_configured_agent_registry(
    client: &NexusClient,
    context: &NexusContext,
) -> anyhow::Result<Response<AgentRegistrySnapshot>> {
```

#### `fetch_configured_active_tap_skill_revision`

```rust
pub async fn fetch_configured_active_tap_skill_revision(
    client: &NexusClient,
    context: &NexusContext,
    agent_id: AgentId,
    skill_id: SkillId,
) -> anyhow::Result<Response<SkillRevisionContext>> {
```

#### `fetch_configured_active_tap_skill_execution_target`

```rust
pub async fn fetch_configured_active_tap_skill_execution_target(
    client: &NexusClient,
    context: &NexusContext,
    agent_id: AgentId,
    skill_id: SkillId,
) -> anyhow::Result<Response<ActiveSkillExecutionTarget>> {
```

#### `fetch_configured_default_tap_dag_executor`

```rust
pub async fn fetch_configured_default_tap_dag_executor(
    client: &NexusClient,
    context: &NexusContext,
) -> anyhow::Result<Response<DefaultDagExecutorRecord>> {
```

#### `fetch_execution_payment`

```rust
pub async fn fetch_execution_payment(
    client: &NexusClient,
    payment_id: sui::types::Address,
) -> anyhow::Result<Response<ExecutionPaymentInnerV1>> {
```

#### `fetch_execution_payment_for_execution`

```rust
pub async fn fetch_execution_payment_for_execution(
    client: &NexusClient,
    context: &NexusContext,
    execution_id: sui::types::Address,
) -> anyhow::Result<Response<ExecutionPaymentInnerV1>> {
```

#### `fetch_agent_payment_vault`

```rust
pub async fn fetch_agent_payment_vault(
    client: &NexusClient,
    vault_id: sui::types::Address,
) -> anyhow::Result<Response<AgentPaymentVaultInnerV1>> {
```

#### `fetch_agent_payment_vault_for_agent`

```rust
pub async fn fetch_agent_payment_vault_for_agent(
    client: &NexusClient,
    context: &NexusContext,
    agent_id: AgentId,
) -> anyhow::Result<Response<AgentPaymentVaultInnerV1>> {
```

#### `resolve_active_skill_revision_context`

```rust
pub fn resolve_active_skill_revision_context<'a>(
    records: &'a [SkillRevisionContext],
    skills: &[SkillRecordContext],
    agent_id: AgentId,
    skill_id: SkillId,
) -> Result<&'a SkillRevisionContext, SkillRevisionLookupError> {
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.talus.network/reference/sdk/actions-tap.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `build a script that syncs our docs to a CMS` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.