workersdk

type Authorization struct {
	// Enforcement is "off" for a Worker without an identity policy, else "shadow" or
	// "enforce".
	Enforcement string `json:"enforcement"`
	Permitted   bool   `json:"permitted"`
	Enforced    bool   `json:"enforced"`
	ReasonCode  string `json:"reasonCode"`
	DecisionKey uint64 `json:"decisionKey"`
	// Job is the parameters the decision covers. A handler acts on these and not on
	// what it was handed at lease time.
	Job        map[string]any `json:"job"`
	Credential *struct {
		Type        string `json:"type"`
		AccessToken string `json:"accessToken"`
		ExpiresAt   int64  `json:"expiresAt"`
	} `json:"credential"`
}

type BPMNError struct {
	Code    string
	Message string
}

type CmdExec struct {
	Name string
	Args []string
	// Env is added to the process's own environment.
	Env []string
}

type CompletingExec interface {
	RunCompleting(ctx context.Context, j Job) (Outcome, error)
}

type CompletingExecFunc func(ctx context.Context, j Job) (Outcome, error)

type ConfiguredWorker struct {
	Name   string         `json:"name"`
	Config map[string]any `json:"config"`
}

type ConnectorPayload struct {
	Kind   string         `json:"kind"`
	Fields map[string]any `json:"fields"`
}

type DecisionReport struct {
	DecisionID string         `json:"decisionId"`
	Inputs     map[string]any `json:"inputs,omitempty"`
	Outputs    map[string]any `json:"outputs,omitempty"`
	Trace      string         `json:"trace,omitempty"`
}

type Document struct {
	ID          string
	Name        string
	ContentType string
}

type Exec interface {
	Run(ctx context.Context, j Job) (map[string]any, error)
}

type ExecFunc func(ctx context.Context, j Job) (map[string]any, error)

type Identity struct {
	ID      string `json:"id"`
	Version string `json:"version"`
	Digest  string `json:"digest,omitempty"`
}

type Job struct {
	JobKey             uint64 `json:"jobKey"`
	Type               string `json:"type"`
	ProcessInstanceKey uint64 `json:"processInstanceKey"`
	ElementInstanceKey uint64 `json:"elementInstanceKey"`
	ProcessDefKey      uint64 `json:"processDefKey"`
	ElementID          string `json:"elementId"`
	Retries            int32  `json:"retries"`
	LeaseToken         uint64 `json:"leaseToken"`
	// IdempotencyKey is the same for every delivery of this task execution and
	// unique to it: hand it to a target that filters duplicates, or check by it before
	// acting, so a job delivered twice does its effect once.
	IdempotencyKey string         `json:"idempotencyKey"`
	Variables      map[string]any `json:"variables"`
	// Worker is a task the engine resolved into plain values, present
	// only for a kind the server no longer serves itself (ADR-0168). Nil for a plain
	// job-worker task, whose work is the customer's own command.
	Connector *ConnectorPayload `json:"connector,omitempty"`
}

type Options struct {
	// Server is the base URL of the Atlas to work for, e.g. http://localhost:8080.
	Server string
	// ID names this worker. It rides on every lease and every report, and it is what
	// the Workers view shows — so give each deployment its own.
	ID string
	// Token, when set, is sent as a bearer credential on every request.
	Token string
	// BrokerKey, when set, is presented when this worker asks whether it may act
	// (Authorize). A server supervising this worker hands it over (ATLAS_BROKER_KEY)
	// only to the process serving a Worker whose credential it brokers per job; without
	// it, the server releases no person's token to this process.
	BrokerKey string
	// Handlers is what this worker serves, keyed by job type. A worker with none is a
	// misconfiguration rather than a process that polls forever over nothing.
	Handlers map[string]Exec
	// Lease is how long the engine holds a job for this worker. It must comfortably
	// exceed how long the work takes: an elapsed lease puts the job back on offer, and
	// the report that finally arrives is fenced out.
	Lease time.Duration
	// Wait is how long a poll may block waiting for work before coming back empty.
	Wait time.Duration
	// Retry is how long to wait after a failed poll before trying again. A worker
	// must not exit because the server was restarting, or because the process using
	// its job type is not deployed yet — both are ordinary and both resolve.
	Retry time.Duration
	// MaxJobs is how many jobs of one type this worker runs at once. A poll leases
	// only as many as there are free places for, so every leased job starts the
	// moment it arrives: leased work nobody is running is work nobody else can take
	// either, and its lease runs down while it waits (ADR-0440).
	MaxJobs int
	// Workers are the worker names this worker holds credentials for, reported
	// to the engine on every poll. Only the worker knows them — once a kind is
	// offloaded the engine holds no credential for it — and the Workers view
	// subtracts them from what deployed models reference to show which names are
	// configured nowhere (ADR-0168). Empty for a worker that serves only plain job
	// types, which need no credential of their own.
	Connectors []string
	// Endpoints are where those workers connect, reduced to scheme, host and port and
	// keyed by worker name — what lets an architecture sketch draw the system a worker
	// reaches when the engine holds no configuration for it (ADR-0471). Reported beside
	// Connectors on every poll; a name with no entry is drawn as holding its endpoint
	// itself.
	Endpoints map[string]string
	// Queries are the form lookups this worker answers, keyed by the job type of the
	// Worker Type answering them (ADR-0473). A query is not a
	// job: nothing about it is durable, and it is polled on a path of its own beside the
	// job poll, under the same identity and for the same Workers.
	Queries map[string]QueryFunc
	// MaxQueries is how many queries of one type this worker answers at once.
	MaxQueries int
	// RetryBackoff is how long a job this worker failed waits before it is offered
	// again, given the attempts it has left after the failure, in nanoseconds; nil means
	// [DefaultRetryBackoff], the delay the server's in-process runner waits too
	// (ADR-0111, amendment 2026-11-04). A Worker Type that runs out here meets the same
	// replication delays as one that runs inside the server — a group Microsoft Graph
	// created a moment earlier is not yet found — so it waits as long before it raises
	// an incident. NoRetryBackoff retries at once.
	RetryBackoff func(retriesLeft int32) int64
	// NoRetryBackoff offers a failed job again at once, as before the amendment; tests
	// that drive a failing job to its incident use it.
	NoRetryBackoff bool
	// HTTP is the client to use; nil means a default one bounded by Lease + Wait.
	HTTP *http.Client
	// Identity is the Worker Type this instance runs, reported on every poll as part of
	// the protocol handshake (ADR-0535 §3) and shown in the server's Workers view. Nil
	// reports none, which a server accepts: an instance an operator runs by hand may
	// not be a packaged Worker Type at all.
	Identity *Identity
	// Logger receives the few lines the worker writes itself — a poll that failed and
	// will be retried, a query answer the server did not take. Each carries the event
	// name under the key "event" ([EventPollFailed]), so an operator can alert on it
	// whatever logger a Worker Type uses. Nil means [slog.Default]; atlas's own worker
	// leaves it nil, so these lines go through the handler `atlas worker` installs.
	Logger *slog.Logger
}

type Outcome struct {
	Variables map[string]any
	Decision  *DecisionReport
	// ToolCalls is a worker's account of what an agent chose to run next
	// (ADR-0253/ADR-0254). It is the second thing in the sentence above: a round's
	// answer is usually not variables at all, it is a choice of activities, and a
	// worker deciding the round is the only one who knows what the model said.
	//
	// Empty is an answer, not an omission — the agent saying the run is finished —
	// so a round that ends completes with variables like any other job.
	ToolCalls []ToolCallReport
}

type QueryFunc func(ctx context.Context, connector string, q lookup.Query) (lookup.Page, error)

type ToolCallReport struct {
	Tool      string         `json:"tool"`
	CallId    string         `json:"callId,omitempty"`
	Arguments map[string]any `json:"arguments,omitempty"`
}

type Worker struct {
	// contains filtered or unexported fields
}