lenso-plugin-sdk 0.4.6

Target-independent Rust authoring SDK for portable Lenso Plugins.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

# Lenso portable Plugin Runtime SDK

This crate is the domain-neutral lowering layer used by product SDKs. It turns
one generated JSON Capability dispatcher into a Wasm Component or a trusted
Process implementation. It intentionally contains no Agent Tool, Ingress,
authentication, or other product semantics.

Plugin projects normally depend on it through the `lenso` facade name:

```toml
[dependencies]
lenso = { package = "lenso-plugin-sdk", version = "0.4.6" }
```

## Migrating from 0.1

Version 0.1 incorrectly exposed Agent-specific `AgentTool` and
`export_agent_tool!` interfaces from the Runtime SDK. Those interfaces were
removed rather than retained as compatibility aliases. Agent Tool authors use
the product SDK and the same annotations as a linked native Plugin:

```rust,ignore
#[lenso::plugin]
#[derive(Clone, Copy, Debug, Default)]
struct TextTools {}

#[lenso_agent_tool_sdk::tool_provider]
impl TextTools {
    #[tool(
        name = "uppercase",
        description = "Convert text to uppercase.",
        execution = "parallel_safe"
    )]
    fn uppercase(arguments: Arguments) -> Result<ExecuteResponse, ExecuteError> {
        // Business implementation.
    }
}
```

Cargo metadata selects `wasm`, `process`, or both outputs. Plugin business code
does not implement transport framing or a target-specific Agent Tool trait.

Native Process output uses the complete-object `lenso.process-stdio@2` profile.
Generated glue validates Host initialization, constructs one Plugin object,
reports invocation settlement separately from its result, and attempts stop once
after the Host drains admitted work. `--lenso-describe` prints the generated
descriptor for build tooling without starting the runtime session.

Plugins with dependencies construct one complete object from exact named routes.
The Capability client is generated from the contract, so business code does not
copy Capability identities or route IDs:

```rust,ignore
const REQUIREMENTS: &[lenso::Requirement] = &[
    lenso::Requirement::one::<DocumentStoreClient>("destination"),
    lenso::Requirement::one::<DocumentStoreClient>("source"),
];

struct SyncPlugin {
    source: DocumentStoreClient,
    destination: DocumentStoreClient,
}

impl lenso::Plugin for SyncPlugin {
    const CONFIGURATION_SCHEMA: Option<&'static str> =
        Some(include_str!("../sync-config.schema.json"));

    fn requirements() -> &'static [lenso::Requirement] {
        REQUIREMENTS
    }

    fn create(context: lenso::CreateContext) -> Result<Self, String> {
        Ok(Self {
            source: context.dependencies().one("source")?.client()?,
            destination: context.dependencies().one("destination")?.client()?,
        })
    }

    fn stop(&self, context: lenso::Ctx) -> Result<(), String> {
        // Optional cleanup through the same exact dependency routes.
        Ok(())
    }
}
```

Each provider invocation receives a fresh `lenso::Ctx`; dependency calls inherit
that invocation's cancellation, budget, permissions, and parent scope. Process
Plugins publish `CONFIGURATION_SCHEMA` and support these named outbound calls.
The current Wasm export remains for Plugins without configuration or
dependencies until its Host Imports world is upgraded to the same Authoring V2
contract.