Go SDK

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

apiVersion: edictum/v1
kind: ContractBundle
defaults:
  mode: enforce
contracts:
  - id: block-dotenv
    type: pre
    tool: read_file
    when:
      args.path: { contains: ".env" }
    then:
      effect: deny
      message: "Read of sensitive file denied: {args.path}"

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

package main

import (
	"context"
	"fmt"
	"log"

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

func main() {
	g, err := guard.FromYAML("contracts.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
		})
	if denied, ok := edictum.AsDenied(err); ok {
		fmt.Println("DENIED:", denied.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 denied, ok := edictum.AsDenied(err); ok {
		fmt.Println("DENIED:", denied.Reason)
	}
}

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

import (
	"context"
	"strings"

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

g := guard.New(
	guard.WithEnvironment("production"),
	guard.WithMode("enforce"),
	guard.WithContracts(
		contract.Precondition{
			Name: "deny-sensitive-paths",
			Tool: "*",
			Check: func(_ context.Context, env envelope.ToolEnvelope) (contract.Verdict, error) {
				if strings.Contains(env.FilePath(), "/.ssh/") {
					return contract.Fail("Access to .ssh is denied"), nil
				}
				return contract.Pass(), nil
			},
		},
	),
	guard.WithOnDeny(func(env envelope.ToolEnvelope, reason, name string) {
		log.Printf("DENIED: %s -- %s", env.ToolName(), reason)
	}),
)

result := g.Evaluate(ctx, "read_file", map[string]any{"path": ".env"})
fmt.Println(result.Verdict)                  // "deny"
fmt.Println(result.DenyReasons[0])           // "Read of sensitive file denied: .env"
fmt.Println(result.Contracts[0].ContractID)  // "block-dotenv"

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

github.com/edictum-ai/edictum-go/
├── guard/           # Top-level API -- New(), Run(), Evaluate(), FromYAML(), FromServer()
├── contract/        # Verdict, Precondition, Postcondition, SessionContract
├── envelope/        # ToolEnvelope, Principal, ToolRegistry, BashClassifier
├── pipeline/        # 5-stage governance 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