Ecosystem Packages

Kuetix Engine is built on a set of lightweight, reusable Go modules. They are split into three groups:

Core modules — required by the engine; pulled in automatically via go.mod when you depend on github.com/kuetix/engine.
Standalone libraries — self-contained utility modules you can adopt independently of the engine.
Standard library modules (std-*) — optional building blocks shipping .wsl workflows + Go transitions for common concerns (authentication, HTTP serving, CLI registration, AI, …). Install one when you need it.

Module	Group	Purpose
`github.com/kuetix/container`	Core	Thread-safe DI container
`github.com/kuetix/helpers`	Core	Shared helper functions
`github.com/kuetix/logger`	Core	Structured logging
`github.com/kuetix/uuid`	Core	Deterministic UUIDv5 helpers
`github.com/kuetix/cryptor`	Library	AES / RSA / Ed25519 / X25519 / CBC encryption helpers
`github.com/kuetix/std-core`	Stdlib	Common transitions (responses, assertions, entities, datetime, pagination, …)
`github.com/kuetix/std-cli`	Stdlib	CLI command-registration transitions used by `kue`
`github.com/kuetix/std-auth`	Stdlib	JWT and password-auth transitions + workflows
`github.com/kuetix/std-http`	Stdlib	HTTP server / workflow router
`github.com/kuetix/std-ai`	Stdlib	LLM prompt + agent transitions (OpenAI / Anthropic / Gemini)

Core Modules

kuetix/container

A tiny, thread-safe dependency injection container for Go.

Module: github.com/kuetix/container

Install:

go get github.com/kuetix/container

Features

Simple singleton storage (ToFetch / Fetch)
Factory-based resolution (ToResolve / Resolve)
Lightweight parameters store (ToParameter / Parameter)
Thread-safe with sync.RWMutex protection
Combined lookup via Get

Quick Start

import c "github.com/kuetix/container"

// Register a singleton
c.ToFetch("app.name", "demo-app")

// Register a factory (called on each Resolve)
c.ToResolve("time.now", func() interface{} {
    return time.Now().String()
})

// Register a parameter
c.ToParameter("http.port", 8080)

// Read values
name := c.Fetch("app.name")         // "demo-app"
now := c.Resolve("time.now")        // calls factory each time
port := c.Parameter("http.port")    // 8080
value := c.Get("app.name")          // checks singletons, then factories

API Reference

Function	Description
`ToFetch(key, value)`	Register a singleton
`ToFetchFunc(key, factory)`	Register a singleton from a factory (eager)
`Fetch(key)`	Retrieve a singleton (panics if missing)
`ToResolve(key, factory)`	Register a factory
`Resolve(key)`	Call a factory (panics if missing)
`Get(key)`	Lookup singletons first, then factories
`ToParameter(key, value)`	Register a parameter
`Parameter(key)`	Retrieve a parameter (panics if missing)
`Has(key)`	Check if key exists in any registry
`CanFetch(key)`	Check if singleton exists
`CanResolve(key)`	Check if factory exists
`HasParameter(key)`	Check if parameter exists
`Reset()`	Clear all registries (for testing)

Usage in Kuetix Engine

The engine uses kuetix/container as its core DI framework. Module transitions, services, and configurations are all registered and resolved through this container. The generated modules/di.go file registers all module transitions using ToResolve.

kuetix/helpers

Shared helper functions used internally by the engine and exposed for reuse.

Module: github.com/kuetix/helpers

Install:

go get github.com/kuetix/helpers

Used by the engine for string/map/file utilities and by generated modules/di.go / modules/meta.go files.

kuetix/logger

Structured logger used throughout the engine and ecosystem packages.

Module: github.com/kuetix/logger

Install:

go get github.com/kuetix/logger

Usage

import "github.com/kuetix/logger"

logger.Debug("Debug message")
logger.Info("Info message")
logger.Warn("Warning message")
logger.Error("Error message")
logger.Fatalf("Fatal: %v", err)

kuetix/uuid

Small utilities around UUID generation and formatting, built on top of github.com/google/uuid.

Module: github.com/kuetix/uuid

Install:

go get github.com/kuetix/uuid

API Reference

import kuuid "github.com/kuetix/uuid"

// Deterministic UUIDv5 derived from an identity string
u := kuuid.IdV5("example")

// Canonical UUID string (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX)
canonical := kuuid.UUId("example")

// Dashless hex (32 chars)
hex := kuuid.Id("example")

// Base64 encoding of the 16-byte UUID
b64 := kuuid.Base64Id("example")

// Remove dashes from a canonical UUID string
clean := kuuid.UId(u.String())

Function	Description	Output Format
`IdV5(identity)`	Deterministic UUIDv5 from string	`uuid.UUID`
`UUId(identity)`	Canonical UUID string	`xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`
`Id(identity)`	Dashless hex string	`xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`
`Base64Id(identity)`	Base64-encoded UUID bytes	Base64 string
`UId(uuidString)`	Remove dashes from UUID	`xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`

Usage in Kuetix Engine

The engine uses kuetix/uuid for generating deterministic identifiers from entity keys, used in workflow context resolution and the helpers.Id() template function.

Standalone Libraries

These modules are self-contained and have no dependency on the engine. Use them in any Go project.

kuetix/cryptor

A small, dependency-light cryptography helper covering symmetric and asymmetric primitives behind a single Cryptor type.

Module: github.com/kuetix/cryptor

License: MIT

Install:

go get github.com/kuetix/cryptor

Constructors

Constructor	Scheme
`NewCryptor()`	Base cryptor (defaults)
`NewCryptorAES(key)`	AES symmetric encryption
`NewCryptorRSA(publicKey, privateKey)`	RSA asymmetric encryption
`NewCryptorEd25519(publicKey, privateKey)`	Ed25519 signing
`NewCryptorX25519(publicKey, privateKey)`	X25519 key exchange

Password-based CBC helpers are also exposed directly, e.g. DecryptCBC(password, ciphertext).

Quick Start

import "github.com/kuetix/cryptor"

c := cryptor.NewCryptorAES("my-32-byte-key...")
ciphertext, err := c.Encrypt("secret")   // (string) -> ([]byte, error)
plaintext, err := c.Decrypt(ciphertext)  // ([]byte) -> (string, error)
// Base64 variants are also available: EncryptBase64 / DecryptBase64

Standard Library Modules

These are optional plug-in packages distributed alongside the engine. Each is its own Go module, ships its own WSL workflows under workflows/, and registers Go transitions under modules/.

kuetix/std-core

Common transitions used by virtually every project: responses, assertions, entity helpers, datetime utilities, pagination, context manipulation.

Module: github.com/kuetix/std-core

Install:

kue package install std-core

Or via Go directly when consuming the package as a library:

go get github.com/kuetix/std-core

kuetix/std-cli

CLI command-registration transitions used by kue and any other CLI app built on the engine.

Module: github.com/kuetix/std-cli

Install:

kue package install std-cli

kuetix/std-auth

JWT generation/validation/refresh and password hashing transitions with companion .wsl workflows (login, register, reset_password, …).

Module: github.com/kuetix/std-auth

Install:

kue package install std-auth

Environment variables consumed:

JWT_SECRET (required — the package refuses to start without it)
JWT_ISSUER, JWT_AUDIENCE (optional)

kuetix/std-http

HTTP server, CORS handling, route registration, and a transition that maps HTTP requests to WSL workflows.

Module: github.com/kuetix/std-http

Install:

kue package install std-http

kuetix/std-ai

AI-oriented transitions and workflows: send prompts to LLM providers and run a think/act agent loop with tool execution.

Module: github.com/kuetix/std-ai

Install:

kue package install std-ai

Included transitions:

ai/prompt.* — OpenAI, Anthropic, Gemini provider calls plus Resolve (model/base-URL resolution) and Prompt (provider router).
ai/agent.* — BuildPrompt, ParseDecision, Decide, ExecuteTool (and its ExecuteWorkflowTool / ExecuteExternalTool variants), AppendTurn, and Run (the full loop).
ai/external.* — HTTP, MCP, and Execute adapters for invoking external/MCP tools.

Environment variables:

Common overrides: AI_API_KEY, AI_MODEL, AI_BASE_URL
Per provider: OPENAI_API_KEY / OPENAI_MODEL / OPENAI_BASE_URL, ANTHROPIC_API_KEY / ANTHROPIC_MODEL / ANTHROPIC_BASE_URL, GEMINI_API_KEY (or GOOGLE_API_KEY) / GEMINI_MODEL / GEMINI_BASE_URL

note

The agent loop and provider routing are implemented inside Go transitions rather than split across WSL states. With engine@v1.0.0 the workflow layer cannot evaluate when/if conditions or re-evaluate accumulating state across revisited states, so the multi-way routing (ai/prompt.Prompt) and the think/act loop (ai/agent.Run) stay in Go.

CLI Reference — kue package and module management commands
Module System — How modules are loaded and resolved
Source repositories — All Kuetix Go modules on GitHub

Core Modules​

kuetix/container​

Features​

Quick Start​

API Reference​

Usage in Kuetix Engine​

kuetix/helpers​

kuetix/logger​

Usage​

kuetix/uuid​

API Reference​

Usage in Kuetix Engine​

Standalone Libraries​

kuetix/cryptor​

Constructors​

Quick Start​

Standard Library Modules​

kuetix/std-core​

kuetix/std-cli​

kuetix/std-auth​

kuetix/std-http​

kuetix/std-ai​

Related Topics​

Core Modules

kuetix/container

Features

Quick Start

API Reference

Usage in Kuetix Engine

kuetix/helpers

kuetix/logger

Usage

kuetix/uuid

API Reference

Usage in Kuetix Engine

Standalone Libraries

kuetix/cryptor

Constructors

Quick Start

Standard Library Modules

kuetix/std-core

kuetix/std-cli

kuetix/std-auth

kuetix/std-http

kuetix/std-ai

Related Topics