Go SDK

go get github.com/edictum-ai/edictum-go

apiVersion: edictum/v1
kind: Ruleset
defaults:
  mode: enforce
rules:
  - id: block-dotenv
    type: pre
    tool: read_file
    when:
      args.path: { contains: ".env" }
    then:
      action: block
      message: "Read of sensitive file blocked: {args.path}"

  - id: block-destructive-commands
    type: pre
    tool: run_command
    when:
      any:
        - args.command: { starts_with: "rm " }
        - args.command: { starts_with: "DROP " }
    then:
      action: block
      message: "Destructive command blocked: {args.command}"

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	edictum "github.com/edictum-ai/edictum-go"
	"github.com/edictum-ai/edictum-go/guard"
)

func main() {
	g, err := guard.FromYAML("rules.yaml")
	if err != nil {
		log.Fatal(err)
	}

	ctx := context.Background()

	// Allowed: normal file read
	result, err := g.Run(ctx, "read_file", map[string]any{"path": "readme.txt"},
		func(args map[string]any) (any, error) {
			return fmt.Sprintf("contents of %s", args["path"]), nil
		})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("OK:", result)

	// DENIED: agent tries to read .env
	_, err = g.Run(ctx, "read_file", map[string]any{"path": ".env"},
		func(args map[string]any) (any, error) {
			return "should never execute", nil
		})
	var blocked *edictum.DeniedError
	if errors.As(err, &blocked) {
		fmt.Println("DENIED:", blocked.Reason)
	}

	// DENIED: agent tries to rm -rf
	_, err = g.Run(ctx, "run_command", map[string]any{"command": "rm -rf /tmp"},
		func(args map[string]any) (any, error) {
			return "should never execute", nil
		})
	if errors.As(err, &blocked) {
		fmt.Println("DENIED:", blocked.Reason)
	}
}

OK: contents of readme.txt
DENIED: Read of sensitive file blocked: .env
DENIED: Destructive command blocked: rm -rf /tmp

import (
	"context"
	"strings"

	"github.com/edictum-ai/edictum-go/guard"
	"github.com/edictum-ai/edictum-go/rule"
	"github.com/edictum-ai/edictum-go/toolcall"
)

g := guard.New(
	guard.WithEnvironment("production"),
	guard.WithMode("enforce"),
	guard.WithRules(
		rule.Precondition{
			Name: "block-sensitive-paths",
			Tool: "*",
			Check: func(_ context.Context, call toolcall.ToolCall) (rule.Decision, error) {
				if strings.Contains(call.FilePath(), "/.ssh/") {
					return rule.Fail("Access to .ssh is blocked"), nil
				}
				return rule.Pass(), nil
			},
		},
	),
	guard.WithOnBlock(func(call toolcall.ToolCall, reason, name string) {
		log.Printf("BLOCKED: %s -- %s", call.ToolName(), reason)
	}),
)

result := g.Evaluate(ctx, "read_file", map[string]any{"path": ".env"})
fmt.Println(result.Decision)                // "block"
fmt.Println(result.BlockReasons[0])         // "Read of sensitive file blocked: .env"
fmt.Println(result.Rules[0].RuleID)         // "block-dotenv"

g, err := guard.FromYAML("rules.yaml", guard.WithMode("observe"))

github.com/edictum-ai/edictum-go/
├── guard/           # Top-level API -- New(), Run(), Evaluate(), FromYAML(), FromServer()
├── rule/            # Decision, Precondition, Postcondition, SessionRule
├── toolcall/        # ToolCall, Principal, ToolRegistry, BashClassifier
├── pipeline/        # 5-stage enforcement pipeline
├── session/         # Session counters, MemoryBackend
├── audit/           # CollectingSink, CompositeSink, StdoutSink
├── redaction/       # RedactionPolicy (word-boundary matching, secret detection)
├── sandbox/         # Path, command, and domain sandboxing
├── yaml/            # YAML bundle loader, evaluator, compiler
├── server/          # Server SDK -- HTTP client, SSE, Ed25519 verification
├── approval/        # Approval backend interface
├── adapter/         # Framework adapters (5)
│   ├── adkgo/       # Google ADK Go
│   ├── langchaingo/ # LangChainGo
│   ├── eino/        # Eino/CloudWeGo
│   ├── anthropic/   # Anthropic SDK Go
│   └── genkit/      # Firebase Genkit
├── telemetry/       # OpenTelemetry integration
└── internal/        # shlex tokenizer, deepcopy utility