CI / Linux x86_64 (Forgejo) (push) Successful in 1m41s

Details

feat: initial fai-module-sdk v0.1.0 with #[fai_module] macro

The SDK provides a stable, ergonomic Rust surface for writing
F∆I Platform modules. A module is now a single decorated
function:

    #[fai_module]
    fn invoke(_ctx: Context, inputs: Inputs)
        -> Result<Outputs, ModuleError>
    {
        let text = inputs.require_text("input")?;
        Ok(Outputs::new().with_text("output", format!("echo: {text}")))
    }

The macro absorbs every piece of WASM-module boilerplate that
previously lived per-repo: the wit_bindgen::generate! call, the
Guest trait impl, the WIT-to-SDK type conversions, the
wit_bindgen::export! glue, and the unsafe_op_in_unsafe_fn allow
attribute. Module repos depend only on fai-module-sdk and need
no wit/ directory of their own — the SDK ships a verified
mirror of the platform's frozen v1.0 WIT contract.

The SDK is the central lever for keeping the contract stable
without freezing module ergonomics. If the platform ever bumps
the WIT contract (additive minor or coordinated v2.0), the
change is absorbed inside the SDK; existing module source
keeps compiling against a new SDK release.

Components in this initial drop:

  crates/fai-module-sdk
      Public types — Context, Inputs, Outputs, Payload,
      ModuleError. Helpers like require_text / require_json /
      with_bytes / with_json. Pure Rust, no wit_bindgen
      dependency in user-facing code.

  crates/fai-module-sdk-macros
      The proc-macro crate that emits the wit_bindgen call,
      the Guest impl, the WIT<->SDK conversion code, and the
      export! invocation. Uses runtime_path to route the
      generated bindings through the SDK's re-export of
      wit_bindgen::rt so user crates need no direct dep.

  wit/world.wit
      Mirror of fai/platform :: wit/world.wit, frozen at v1.0.
      A snapshot test (crates/fai-module-sdk/tests/wit_freeze.rs)
      asserts the SHA-256 matches the platform constant; CI
      fails if the two ever drift.

  examples/echo
      Reference module that demonstrates the entire authoring
      surface. Compiles to wasm32-wasip2 with the correct
      v1.0 imports baked in (verified manually; CI runs the
      same build).

Tests: 7 unit tests + 1 snapshot test. Cargo fmt and clippy
clean across the workspace and the example.

Forgejo CI workflow mirrors the platform pattern (manual
external-URL checkout + libssl-dev system deps + wasm32-wasip2
target + workspace fmt/clippy/build/test + example wasm build).

Signed-off-by: flemming-it <sf@flemming.it>

2026-05-01 02:23:44 +02:00

2.1 KiB

Raw Blame History

fai-module-sdk

Stable, ergonomic Rust surface for writing F∆I Platform modules.

A module written against this crate looks like:

use fai_module_sdk::prelude::*;

#[fai_module]
fn invoke(_ctx: Context, inputs: Inputs) -> Result<Outputs, ModuleError> {
    let text = inputs.require_text("input")?;
    Ok(Outputs::new().with_text("output", format!("echo: {text}")))
}

That single function — plus a Cargo.toml listing fai-module-sdk as a dependency — is the entire module. The #[fai_module] macro generates the wit_bindgen invocation, the Guest implementation, the type conversions, and the wit_bindgen::export! glue behind the scenes.

What the SDK gives you

You get	Instead of
`Inputs::require_text("name")`	manual `match payload { Payload::Text(s) => ..., _ => ... }`
`Outputs::new().with_json(...)?`	building `Vec<(String, Payload)>` by hand
`ModuleError::invalid_input("...")`	constructing WIT `invocation-error` variants
`#[fai_module]`	`wit_bindgen::generate!` + `Guest` impl + `export!` + `#![allow(unsafe_op_in_unsafe_fn)]`

Stability

The SDK insulates module code from the underlying WIT contract (fai:platform, frozen at v1.0 in the platform repo). The WIT may evolve in additive minor versions or, eventually, a coordinated v2.0; the SDK absorbs that change so existing module code keeps compiling.

The SDK ships its own copy of wit/world.wit so that the proc-macro can embed the contract via include_str! at compile time. A snapshot test (crates/fai-module-sdk/tests/wit_freeze.rs) asserts the SHA-256 matches the platform's frozen hash — if the two ever drift, CI fails.

Versioning

Track	Stability
WIT contract (`fai:platform`)	Frozen at v1.0 in the platform repo
`fai-module-sdk` Rust API	Semver; v0.x while ergonomics evolve
Per-module versions	Each module repo's own concern

License

Apache-2.0. See LICENSE.

Author: Dr. Stefan Flemming, Flemming.AI platform@flemming.ai Repository: https://git.flemming.ws/fai/module-sdk