Go Data Placement

go get github.com/neutron-ai/neutron/packages/sdk-go

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "time"

    neutron "github.com/neutron-ai/neutron/packages/sdk-go"
)

func requiredEnv(name string) (string, error) {
    value := os.Getenv(name)
    if strings.TrimSpace(value) == "" {
        return "", fmt.Errorf("%s is required", name)
    }
    return value, nil
}

func neutronRequest(
    ctx context.Context,
    httpClient *http.Client,
    baseURL string,
    token string,
    method string,
    path string,
    body map[string]any,
) (map[string]any, error) {
    var requestBody io.Reader
    if body != nil {
        payload, err := json.Marshal(body)
        if err != nil {
            return nil, err
        }
        requestBody = bytes.NewReader(payload)
    }

    request, err := http.NewRequestWithContext(
        ctx,
        method,
        strings.TrimRight(baseURL, "/")+path,
        requestBody,
    )
    if err != nil {
        return nil, err
    }
    request.Header.Set("authorization", "Bearer "+token)
    request.Header.Set("content-type", "application/json")

    response, err := httpClient.Do(request)
    if err != nil {
        return nil, err
    }
    defer response.Body.Close()

    rawBody, err := io.ReadAll(response.Body)
    if err != nil {
        return nil, err
    }
    if response.StatusCode >= 400 {
        return nil, fmt.Errorf("Neutron request failed: %s", response.Status)
    }
    output := map[string]any{}
    if len(rawBody) > 0 {
        err = json.Unmarshal(rawBody, &output)
    }
    return output, err
}

func provisionNuclei(
    ctx context.Context,
    httpClient *http.Client,
    baseURL string,
    workspaceKey string,
) error {
    profiles := []map[string]any{
        {
            "nucleusId": "product-knowledge-global",
            "name":      "Global product knowledge",
            "placement": map[string]any{
                "mode":      "global",
                "guarantee": "none",
                "notes":     []string{"Approved global knowledge; no jurisdictional storage guarantee."},
            },
        },
        {
            "nucleusId": "support-operations-weur",
            "name":      "Western Europe support operations",
            "placement": map[string]any{
                "mode":           "regional",
                "regionHint":     "weur",
                "r2LocationHint": "weur",
                "guarantee":      "best_effort_regional",
                "notes":          []string{"Latency preference only; not a legal residency boundary."},
            },
        },
        {
            "nucleusId": "regulated-cases-eu",
            "name":      "EU regulated case memory",
            "placement": map[string]any{
                "mode":                     "jurisdictional",
                "jurisdiction":             "eu",
                "regionalServicesRequired": true,
                "metadataBoundaryRequired": true,
                "geoKeyManagerRequired":    false,
                "guarantee":                "jurisdictional_storage",
                "notes": []string{
                    "Requires the EU Durable Object jurisdiction and matching EU archive binding.",
                    "Processing, logs, metadata, keys, retention, and contracts require separate verification.",
                },
            },
        },
    }

    for _, profile := range profiles {
        if _, err := neutronRequest(ctx, httpClient, baseURL, workspaceKey, http.MethodPost, "/v1/nuclei", profile); err != nil {
            return err
        }
    }
    return nil
}

type memoryRouter struct {
    global        *neutron.Client
    westernEurope *neutron.Client
    euRegulated   *neutron.Client
}

func newMemoryRouter(baseURL string) (*memoryRouter, error) {
    globalToken, err := requiredEnv("NEUTRON_GLOBAL_TOKEN")
    if err != nil {
        return nil, err
    }
    westernEuropeToken, err := requiredEnv("NEUTRON_WEUR_TOKEN")
    if err != nil {
        return nil, err
    }
    euToken, err := requiredEnv("NEUTRON_EU_TOKEN")
    if err != nil {
        return nil, err
    }

    global, err := neutron.NewClient(neutron.Options{
        BaseURL: baseURL, Token: globalToken, NucleusID: "product-knowledge-global",
    })
    if err != nil {
        return nil, err
    }
    westernEurope, err := neutron.NewClient(neutron.Options{
        BaseURL: baseURL, Token: westernEuropeToken, NucleusID: "support-operations-weur",
    })
    if err != nil {
        return nil, err
    }
    euRegulated, err := neutron.NewClient(neutron.Options{
        BaseURL: baseURL, Token: euToken, NucleusID: "regulated-cases-eu",
    })
    if err != nil {
        return nil, err
    }
    return &memoryRouter{global: global, westernEurope: westernEurope, euRegulated: euRegulated}, nil
}

func (router *memoryRouter) storeGlobalProductKnowledge(ctx context.Context, text string) error {
    _, err := router.global.Remember(ctx, map[string]any{
        "scopeId": "kb:approved-products", "type": "knowledge",
        "privacyClass": "public", "text": text,
    })
    return err
}

func (router *memoryRouter) storeWesternEuropeSupportLesson(ctx context.Context, text string) error {
    _, err := router.westernEurope.Remember(ctx, map[string]any{
        "scopeId": "history:support-resolutions", "type": "tool_lesson",
        "privacyClass": "tenant", "text": text,
    })
    return err
}

func (router *memoryRouter) storeEURegulatedCase(
    ctx context.Context,
    caseID string,
    minimizedSummary string,
) error {
    _, err := router.euRegulated.Remember(ctx, map[string]any{
        "scopeId": "case:" + caseID, "type": "experience",
        "privacyClass": "user_private", "text": minimizedSummary,
        "metadata": map[string]any{
            "dataClass": "eu-regulated-case", "source": "approved-case-summary",
        },
    })
    return err
}

func (router *memoryRouter) euCaseContext(ctx context.Context) (map[string]any, error) {
    return router.euRegulated.AgentContext(ctx, map[string]any{
        "scopeIds": []string{
            "case:case-4821", "policy:eu-case-handling", "kb:approved-products",
        },
        "agentId":       "agent:eu-case-support",
        "task":          "Prepare the next authorized case-support step.",
        "privacyClasses": []string{"tenant", "user_private"},
        "tokenBudget":   1200,
        "cachePolicy": map[string]any{
            "mode": "prefer_cache", "keyMode": "intent_profile", "ttlSeconds": 120,
            "includeDynamicRag": true, "allowSensitive": false,
        },
    })
}

func verifyEUReadiness(
    ctx context.Context,
    httpClient *http.Client,
    baseURL string,
    euToken string,
) error {
    _, err := neutronRequest(ctx, httpClient, baseURL, euToken, http.MethodGet, "/v1/nuclei/regulated-cases-eu/placement", nil)
    if err != nil {
        return err
    }
    health, err := neutronRequest(ctx, httpClient, baseURL, euToken, http.MethodGet, "/v1/nuclei/regulated-cases-eu/health", nil)
    if err != nil {
        return err
    }
    blocking := map[string]bool{
        "jurisdictional_do_subnamespace_unavailable": true,
        "jurisdictional_archive_bucket_missing":     true,
    }
    if warnings, ok := health["warnings"].([]any); ok {
        for _, warning := range warnings {
            if value, ok := warning.(string); ok && blocking[value] {
                return fmt.Errorf("EU Nucleus is not ready: %s", value)
            }
        }
    }
    return nil
}

func main() {
    ctx := context.Background()
    httpClient := &http.Client{Timeout: 30 * time.Second}
    baseURL, err := requiredEnv("NEUTRON_API_URL")
    if err != nil {
        panic(err)
    }
    workspaceKey, err := requiredEnv("NEUTRON_WORKSPACE_API_KEY")
    if err != nil {
        panic(err)
    }
    if err := provisionNuclei(ctx, httpClient, baseURL, workspaceKey); err != nil {
        panic(err)
    }
    router, err := newMemoryRouter(baseURL)
    if err != nil {
        panic(err)
    }
    if _, err := router.euCaseContext(ctx); err != nil {
        panic(err)
    }
    euToken, _ := requiredEnv("NEUTRON_EU_TOKEN")
    if err := verifyEUReadiness(ctx, httpClient, baseURL, euToken); err != nil {
        panic(err)
    }
}