> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fireweave.ai/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Official FireWeave SDK documentation.
> Product noun is control point. OpenFeature and the wire protocol use flagKey — do not invent controlPointKey.
> Do not invent APIs, packages, env vars, or endpoints. Guardrails are a typed stub (UnsupportedCapability). OpenFeature Tracking (spec section 6) is not implemented.
> registerTarget and identify exist on Node, Python, and Web only. Go and Java have no target-registration API on master.
> sendExposure defaults to false. Java close() does not flush exposures.

# Go

> Install and use the FireWeave Go SDK to evaluate flags, drive releases, and report exposures and signals. Target registration is not in this SDK.

The Go module is `github.com/FireWeave-HQ/fireweave-sdk/sdks/go`. It evaluates flags through `client.Flags().Evaluate`, drives a **release** lifecycle, and records **exposures** and **signals**. OpenFeature and the wire protocol use `flagKey`.

<Warning>
  This module is **not published** as a tagged module on the Go proxy (verified 2026-08-17: `proxy.golang.org` returned 404). There is no working `go get` of a released version. Install with a `replace` directive from a checkout.
</Warning>

<Warning>
  **`RegisterTarget` is not in this SDK.** There is no `RegisterTarget` / `register_target` symbol under `sdks/go` on `master`. Pass properties on each evaluate call. See [Targeting and targets](/concepts/targeting).
</Warning>

## Supported versions

From `go.mod` and the compatibility matrix:

|                            | Value                                           |
| -------------------------- | ----------------------------------------------- |
| Module                     | `github.com/FireWeave-HQ/fireweave-sdk/sdks/go` |
| Package version (matrix)   | `0.1.0`                                         |
| `go` directive             | `1.25.12`                                       |
| OpenFeature                | `github.com/open-feature/go-sdk v1.17.2`        |
| PostHog (optional adapter) | `github.com/posthog/posthog-go v1.22.0`         |

CI runs `1.25.x` and `stable`. Document the `go.mod` floor (`1.25.12`); do not treat the floating `stable` cell as a support guarantee.

<Note>
  The quickstart uses `v0.0.0` + `replace`. The matrix says package version `0.1.0`. No public module tag was verified. **NEEDS VERIFICATION** of any existing git tags.
</Note>

## Install

From `docs/quickstart.md`. Until the module path is public, use a `replace`:

```
require github.com/FireWeave-HQ/fireweave-sdk/sdks/go v0.0.0
replace github.com/FireWeave-HQ/fireweave-sdk/sdks/go => ../fireweave-sdk/sdks/go
```

```bash theme={null}
git clone https://github.com/FireWeave-HQ/fireweave-sdk
```

Do not run `go get github.com/FireWeave-HQ/fireweave-sdk/sdks/go@latest` as if a released tag exists.

## Initialize

Every blocking call takes `context.Context`.

```go theme={null}
package main

import (
	"context"
	"fmt"

	"github.com/FireWeave-HQ/fireweave-sdk/sdks/go/adapters/inmemory"
	"github.com/FireWeave-HQ/fireweave-sdk/sdks/go/fireweave"
	fwprovider "github.com/FireWeave-HQ/fireweave-sdk/sdks/go/openfeature"
	of "github.com/open-feature/go-sdk/openfeature"
)

func main() {
	ctx := context.Background()

	adapter := inmemory.New(inmemory.WithFlags(map[string]inmemory.Flag{
		"new-checkout": {Type: fireweave.FlagTypeBoolean, Enabled: true, Value: true, Variant: "on"},
	}))
	runtime := fireweave.NewRuntime(adapter, fireweave.Config{})
	client := fireweave.NewClient(runtime)

	if err := of.SetProviderAndWait(fwprovider.NewProvider(client)); err != nil {
		panic(err)
	}

	enabled := of.NewClient("app").Boolean(ctx, "new-checkout", false,
		of.NewEvaluationContext("user_42", nil))
	fmt.Println("new-checkout:", enabled)

	of.Shutdown()
}
```

`runtime.Initialize(ctx)` / `Flush(ctx)` / `Shutdown(ctx)`. Provider: `Init` / `InitWithContext`, `Shutdown` / `ShutdownWithContext`.

## Configuration and authentication

`fireweave.Config` on the runtime: `Limits`, `RequireTargetingKey`, `GlobalContext`. **No API URL or key on the runtime.**

`adapters/remote.Config`:

| Field            | Env                  | Default                     |
| ---------------- | -------------------- | --------------------------- |
| `APIURL`         | `FW_API_URL`         | required on init if unset   |
| `APIKey`         | `FW_PROJECT_API_KEY` | required on init if unset   |
| `AllowedHosts`   | —                    | API URL hostname + loopback |
| `RequestTimeout` | —                    | 3s                          |
| `CloseTimeout`   | —                    | 10s                         |
| `HTTPClient`     | —                    | tests                       |

```go theme={null}
import "github.com/FireWeave-HQ/fireweave-sdk/sdks/go/adapters/remote"

adapter := remote.New(remote.Config{
	APIURL: os.Getenv("FW_API_URL"),
	APIKey: os.Getenv("FW_PROJECT_API_KEY"),
})
```

Auth: `Authorization: Bearer <key>`. Paths: `/v1/flags/evaluate`, `/v1/capture` only — **no** `/v1/targets/register`.

`FW_POSTHOG_HOST` and `FW_SECRET_KEY` appear in `examples/go/main.go` only. They are **not** read by the remote adapter.

See [Configuration and auth](/production/configuration).

## Targets

**Not in this SDK.** There is no registration API on `master`. The compatibility matrix marks it planned. Pass `targetingKey` and attributes on each `Evaluate` / OpenFeature call.

See [Targeting and targets](/concepts/targeting).

## Flags (no `controlPoints` namespace)

Go has **`Flags()` only**. There is no `controlPoints` / `control_points` facade and **no** `GetBooleanValue`-style helpers on `Flags`.

`FlagType`: `"boolean"`, `"string"`, `"integer"`, `"float"`, `"object"`.

```go theme={null}
fwCtx := fireweave.EvaluationContext{
	TargetingKey: "org_01HZXEXAMPLE0000000000001",
	Attributes:   map[string]any{"tier": "pro", "region": "us"},
}
decision := client.Flags().Evaluate(ctx, "theme", fireweave.FlagTypeString, "light", fwCtx, fireweave.EvaluateOptions{})
if decision.Error != nil {
	fmt.Printf("default %v (%s: %s)\n", decision.Value, decision.Error.Kind, decision.Error.Message)
} else {
	fmt.Printf("value=%v variant=%q reason=%s\n", decision.Value, decision.Variant, decision.Reason)
}
```

`EvaluateOptions`: `IncludePayload`, `SendExposure *bool` (nil / unset means default **false**). Evaluation **never returns an error**: failures are `Decision{Reason: ERROR}`.

Payload via `fireweave.WithIncludePayload(ctx)` (Go context; OpenFeature has no per-call provider options).

See [Control points](/concepts/control-points).

## Releases

`SetContext` / `Start` / `Complete` / `Fail` **return `error`**, not a result struct. `Start`/`Complete`/`Fail` take the `rolloutID` string.

```go theme={null}
release := fireweave.ReleaseContext{
	RolloutID: "rollout_example_checkout_redesign",
	ChangeID:  "chg_01HZXEG0000000000000000001",
	StampIDs:  []string{"stmp_01HZXEG0000000000000000001"},
}
if err := client.Releases().SetContext(ctx, release); err != nil {
	log.Fatal(err)
}
if err := client.Releases().Start(ctx, release.RolloutID); err != nil {
	log.Fatal(err)
}
```

`rolloutId` 1–128 characters; `stampIds` 1–64 unique `stmp_` + 26 Crockford characters; optional `chg_` change ID.

See [Releases](/concepts/releases).

## Exposures

```go theme={null}
_, err := client.Exposures().Record(ctx, fireweave.Exposure{
	TargetingKey: "user_42",
	FlagKey:      "new-checkout",
	Variant:      "on",
	Value:        true,
})
n, err := client.Exposures().Flush(ctx)
_ = client.Exposures().Pending()
```

`SendExposure` on evaluate defaults to **false**.

See [Exposures](/concepts/exposures).

## Signals

```go theme={null}
err := client.Signals().RecordHealth(ctx, fireweave.HealthSignal{
	Name: "provider", Status: "ok", RolloutID: release.RolloutID,
})
_ = client.Signals().RecordError(ctx, fireweave.ErrorSignal{Name: "checkout", Message: "failed"})
_ = client.Signals().RecordMetric(ctx, fireweave.MetricSignal{Name: "latency_ms", Value: 42})
_ = client.Signals().RecordOutcome(ctx, fireweave.OutcomeSignal{Name: "checkout", Status: "completed"})
```

See [Signals and outcomes](/concepts/signals).

## Capabilities

```go theme={null}
caps := client.Capabilities().Get()
ops := client.Capabilities().Operations()
client.Capabilities().Invoke("capabilities.get")
```

`Guardrails().Check` is a stub.

See [Capabilities](/concepts/capabilities).

## Adapters

| Package               | Use                                     |
| --------------------- | --------------------------------------- |
| `…/adapters/remote`   | Production fw-server                    |
| `…/adapters/inmemory` | Tests / offline (`New(WithFlags(...))`) |
| `…/adapters/posthog`  | Direct PostHog escape hatch             |

There is **no** local/dev adapter (`FireweaveLocalAdapter`) on Go.

`adapters/posthog.Config` includes `ProjectAPIKey`, `SecretKey`, `Endpoint`, `AllowedHosts`, `LocalEvaluationOnly`, `FlagRequestTimeout`, `FlagRequestRetries` (default 0), `SendExposureEvents` (default false), `CloseTimeout`, `Transport`. Default PostHog allowlist: five PostHog hosts + loopback.

See [Adapters](/concepts/adapters).

## OpenFeature

Package `openfeature`, constructor `NewProvider(*fireweave.Client)`. Metadata name `"fireweave"`.

Resolvers: `BooleanEvaluation`, `StringEvaluation`, `FloatEvaluation`, `IntEvaluation` (`int64`), `ObjectEvaluation`.

FireWeave ships one provider hook: reserved-key **guard**. No `controlPoints` naming. Tracking is **not implemented**.

See [OpenFeature](/openfeature).

## Errors

`fireweave.Error` with `ErrorKind` constants — the same 15 kinds. Implements `error`. Evaluation still returns a `Decision`; extension methods return `error`.

See [Errors](/production/errors).

## Testing

`adapters/inmemory` with `WithFlags`. Harness env: `FIREWEAVE_TEST_SERVER_URL` or `FW_TEST_SERVER_URL`. The test-server stub does **not** implement target registration.

See [Testing](/testing).

## Shutdown

```go theme={null}
shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
_ = of.ShutdownWithContext(shutdownCtx)
// or: runtime.Shutdown(ctx)
```

See [Initialize, ready, shutdown](/production/lifecycle).

## Not in this SDK

* `RegisterTarget` / `register_target`
* `controlPoints` / `control_points` namespace
* Typed getters (`GetBooleanValue`, …) on `Flags`
* Local/dev adapter
* Working guardrails
* OpenFeature Tracking

## Next

<Card title="Quickstart" href="/quickstart">
  Offline evaluate in every language.
</Card>

<Card title="Compatibility" href="/sdks/compatibility">
  Type split, adapters, and conformance.
</Card>