Edge SDK (Go) — Edge Adapter

The adapter.EdgeAdapter interface (github.com/Zequent/zqnt-edge-sdk-go/v2/adapter) is the core contract of the Go Edge SDK — the direct hardware-command surface, one method per operation, plus SendCustomCommand for everything else. See the Overview for what this SDK covers.

How it works

Zequent Backend  ──(gRPC)──>  adapter/grpc.Server  ──(delegates)──>  Your EdgeAdapter implementation

edgesdk.NewEdgeClient registers the gRPC server for you (see Quickstart) — you never touch adapter/grpc directly, just implement EdgeAdapter and hand it to NewEdgeClient.

Implementing the interface

Embed adapter.UnimplementedEdgeAdapter in your concrete type to get NOT_IMPLEMENTED defaults for every method, then override only what your hardware supports:

type MyDroneAdapter struct {
    adapter.UnimplementedEdgeAdapter
    drone *hardware.Drone
}

func (a *MyDroneAdapter) TakeOff(ctx context.Context, req *domains.TakeOffRequest) (*domains.CommandResult, error) {
    if err := a.drone.TakeOff(req.Coordinates.Alt); err != nil {
        return domains.Error(err.Error(), req.SN), nil
    }
    return domains.SuccessWithTID("takeOff accepted", req.TID, req.SN), nil
}

Note the pattern: a hardware-side failure is returned as domains.Error(...) inside a successful (*CommandResult, nil) return, not as a Go error — the error return is for transport/protocol failures. Both are distinct from NOT_IMPLEMENTED, which UnimplementedEdgeAdapter already handles for anything you don't override.

Command reference

Flight control

Manual control

Dock operations

Asset management

Camera and gimbal

Live streaming

Debug and maintenance

Detection streaming

Capability reporting

Each Capability carries Command, Description, Available, UnavailableReason, Metadata, TargetType, TargetRef, SchemaVersion, InputSchema/OutputSchema (JSON Schema), Errors, Events, Requirements and SkillID — see adapter/domains/capability.go.

Task execution

See Upgrading from 1.3.

Custom commands

Reporting a command's outcome

When a command runs as part of a Skill execution, a successful answer means accepted, not finished: the step completes only when your adapter publishes a command execution event for it. That holds for every custom command, and for TakeOff, GoTo, LookAt and ReturnToHome. The id the platform waits on is the request's TID, so publish under it — RUNNING with Progress while it runs, then exactly one of CommandExecutionSucceeded (optionally with Output), CommandExecutionFailed or CommandExecutionCancelled:

type MyDroneAdapter struct {
    adapter.UnimplementedEdgeAdapter
    live livedata.LiveDataService // set to client.LiveData() after NewEdgeClient
}

func (a *MyDroneAdapter) SendCustomCommand(ctx context.Context, req *domains.CustomCommandRequest) (*domains.CommandResult, error) {
    if req.CommandID != "mission.waypoint.execute" {
        return domains.NotImplemented("unknown command "+req.CommandID, req.SN), nil
    }
    // The request's TID is the id the platform waits on
    go a.flyRoute(req.SN, req.TID, req.Params)
    return domains.SuccessWithTID("route accepted", req.TID, req.SN), nil
}

func (a *MyDroneAdapter) flyRoute(sn, executionID string, params map[string]any) {
    // ... fly the route, publishing CommandExecutionRunning events with Progress as it goes ...
    _ = a.live.PublishCommandExecutionEvent(context.Background(), &domains.CommandExecutionEvent{
        SN:                  sn,
        ExternalExecutionID: executionID,
        CommandID:           "mission.waypoint.execute",
        Status:              domains.CommandExecutionSucceeded,
    })
}

Without a terminal event the Skill waits until it times out. To cancel, the platform calls StopTask with that same id.

CommandResult

Every non-streaming command returns *domains.CommandResult:

type CommandResult struct {
    Success    bool
    Message    string
    TID        string
    SN         string
    ResultType ResultType // ResultTypeSuccess | ResultTypeError | ResultTypeNotImplemented
}

Construct one with the matching helper rather than the struct literal directly:

result.IsSuccess() / result.IsNotImplemented() are nil-safe convenience checks.