lark-channel 0.5.0

Lark/Feishu Channel SDK for Rust
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

# lark-channel

Lark/Feishu Channel SDK for Rust.

This repository is an early community scaffold for a Rust SDK that mirrors the role of the official Channel SDK family:

- `channel-sdk-go`
- `channel-sdk-java`
- `channel-sdk-python`
- `channel-sdk-node`

The first target is to support agent/bot bridges such as `lark-coding-agent-bridge-rs`: inbound events, normalized messages, streaming replies, media downloads, and interactive card callbacks.

## Status

Experimental. The crate currently contains the public module skeleton, shared data types, an OpenAPI foundation for app and tenant access-token management, outbound text and native Markdown/post messaging, CardKit 2.0 creation and update helpers, high-level Markdown streaming messages and replies with long-content continuation, idempotency options, an early WebSocket endpoint/connection foundation, inbound message and card action parsing, normalized inbound text/post/mention handling, lightweight inbound resource descriptors, split-packet event reassembly, a single-connection event consumer, a reconnecting event loop with timer-driven heartbeat support, and a minimal echo bot example.

## Planned Modules

- `config`: app id/secret, Feishu/Lark domain selection, SDK source metadata
- `event`: normalized inbound events
- `message`: normalized messages, outbound content, and high-level message sending
- `card`: validated CardKit 2.0 primitives and common component builders
- `media`: resource descriptors and download/upload helpers
- `client`: async client trait for transport implementations
- `lark_openapi`: low-level Feishu/Lark OpenAPI auth, transport, response parsing, IM message primitives, and WebSocket endpoint discovery

## Crate Name

The repository is named `channel-sdk-rust` to match LarkSuite's official SDK naming style. The published Rust crate is `lark-channel`, and the Rust library target is `lark_channel`, so users can import it as:

```toml
lark-channel = "0.5"
```

```rust
use lark_channel::{ChannelConfig, Domain};
```

## Examples

Examples live in [examples](examples).

The token example verifies the current OpenAPI foundation by requesting app and tenant access tokens:

```bash
export LARK_APP_ID=cli_xxx
export LARK_APP_SECRET=xxx
cargo run --example tokens
```

The example reads credentials from environment variables. Applications using this SDK may load those values from their own configuration system, secret manager, or local `.env` workflow before constructing `ChannelConfig`.

`ChannelConfig` defaults to `Domain::Feishu`, which uses `https://open.feishu.cn`. Use `Domain::Lark` when targeting `https://open.larksuite.com`.

Minimal text messages can be sent through the high-level message sender:

```rust
use lark_channel::lark_openapi::{OpenApiClient, ReqwestOpenApiTransport};
use lark_channel::{ChannelConfig, MessageSender, Recipient};

// Inside async application code:
let app_id = "cli_xxx";
let app_secret = "app_secret";
let chat_id = "oc_xxx";

let config = ChannelConfig::new(app_id, app_secret);
let openapi = OpenApiClient::new(config, ReqwestOpenApiTransport::new());
let sender = MessageSender::new(openapi);
let message_id = sender
    .text_message(Recipient::Chat(chat_id.to_owned()), "hello")
    .send()
    .await?;
```

`app_id` and `app_secret` come from the Lark/Feishu developer console. See [docs/messages.md](docs/messages.md) for message and streaming semantics, [docs/lark-api.md](docs/lark-api.md) for the implemented Lark/Feishu OpenAPI mapping, and [examples/README.md](examples/README.md) for runnable example configuration.

## Roadmap

See [docs/roadmap.md](docs/roadmap.md) for the development plan.

The next milestone is:

6. Media helper APIs.