agentwire

type Attachment = wire.Attachment

type AuthState string

type Classification struct {
	Class   FailureClass
	Code    string
	Message string
}

type Credentials struct {
	// Format names the provider wire: "anthropic" or "openai".
	Format string
	// BaseURL overrides the provider endpoint. Empty uses the provider
	// default; an http(s) URL turns the SDK into a gateway client.
	BaseURL string
	// APIKey is the bearer credential.
	APIKey string
	// Headers are extra HTTP headers for every provider call.
	Headers map[string]string
}

type Decision = wire.Decision

type Delivery = wire.Delivery

type Detection struct {
	Harness Harness
	// Path is the resolved binary, empty when the harness is not installed.
	Path string
	// Version is the first line of `<bin> --version`, empty when unknown.
	Version string
	// Supported reports that the binary exists and meets the version floor.
	Supported bool
	// Ready reports Supported && Auth == AuthOK. Runtime.Detect sets it for
	// every harness, so a picker reads one field.
	Ready bool
	// Auth is the best-effort login state.
	Auth AuthState
	// AuthDetail is a short note from the auth probe, such as an account
	// email. It never contains a token.
	AuthDetail string
	// Features is the static capability table for the harness.
	Features Features
	// Detail explains an unsupported verdict.
	Detail string
}

type Detector interface {
	Detect(ctx context.Context) (Detection, error)
}

type Driver interface {
	Name() string
	Start(ctx context.Context, req StartRequest) (Session, error)
	Resume(ctx context.Context, req StartRequest) (Session, error)
}

type Event = wire.Event

type EventType = wire.EventType

type FailureClass string

type FakeDriver struct {
	// Script is a shell program. Empty uses FakeScriptEnv, then
	// DefaultFakeScript.
	Script string
	// Dir overrides the working directory.
	Dir string
	// ModelList is the list Runtime.Models returns. Empty reads
	// FakeModelsEnv.
	ModelList []ModelInfo
	// NoSteer makes every steer fail with ErrUnsupported, so Send holds a
	// prompt during a turn and sends it after the result.
	NoSteer bool
}

type Features struct {
	// MCPInject says how MCPServers reach the harness.
	MCPInject MCPCapability
	// SkillsInject says how Skills reach the harness.
	SkillsInject SkillSupport
	// Instructions reports per-session instruction support.
	Instructions bool
	// Attachments reports prompt image support.
	Attachments bool
	// Resume reports session resume support.
	Resume bool
	// Permissions reports that the harness asks before a tool runs and the
	// library can answer.
	Permissions bool
	// FS reports that the harness can route file reads and writes to
	// StartRequest.FS.
	FS bool
	// Models reports that Runtime.Models can list the harness models.
	Models bool
	// SetModel reports that a live session implements ModelSetter.
	SetModel bool
	// Steer reports that a live session implements Steerer and the vendor
	// takes input during a running turn.
	Steer bool
}

type FileSystem interface {
	ReadTextFile(ctx context.Context, path string) (string, error)
	WriteTextFile(ctx context.Context, path, content string) error
}

type Harness string

type HomeFile struct {
	Key  string       `json:"key"`
	Kind HomeFileKind `json:"kind"`
	// User is the path relative to the user's home folder.
	User string `json:"user"`
	// Home is the path relative to the harness home.
	Home string `json:"home"`
	// Format is json, toml, or markdown for a file, and empty for a folder.
	Format string `json:"format,omitempty"`
	// Keys are the keys that a HomeKeys entry copies. A TOML key can be
	// "table.key". Nil copies each key that no other entry of the same
	// home file names.
	Keys []string `json:"keys,omitempty"`
	// Share is the default: true shares the user file.
	Share bool `json:"share"`
	// Login marks a login file. The auth mode decides its share.
	Login bool `json:"login,omitempty"`
	// Hooks marks a file or a key that holds user hooks.
	Hooks bool `json:"hooks,omitempty"`
	// OwnEnv is the env key that points the vendor at the own copy.
	OwnEnv string `json:"own_env,omitempty"`
}

type HomeFileKind string

type HomeKey struct {
	// File is the path relative to the harness home.
	File string `json:"file"`
	// Key is a top-level JSON key, or a TOML key with its table:
	// "table.key".
	Key   string `json:"key"`
	Value any    `json:"value"`
	// Keep keeps a value that the file holds already.
	Keep bool `json:"keep,omitempty"`
}

type InstallMethod string

type InstallRecipe struct {
	Harness Harness
	Method  InstallMethod
	// Package is the npm package, the brew formula, the script URL, or the
	// download URL.
	Package string
	// Bin is the binary that the install puts on PATH.
	Bin string
	// Requires lists the programs that must be on PATH before the install.
	Requires []string
	// Update is the vendor self-update command after Bin. Nil means install
	// again.
	Update []string
	// UpdateTo is the command after Bin that installs one version. The
	// version goes last. Nil means install again.
	UpdateTo []string
	// UpdateOffEnv is the env that stops the vendor auto-update.
	UpdateOffEnv map[string]string
	// UpdateOffArgs are launch args that stop the vendor auto-update.
	UpdateOffArgs []string
}

type LedgerEntry struct {
	Key        string    `json:"key"`
	Harness    string    `json:"harness"`
	PID        int       `json:"pid"`
	PGID       int       `json:"pgid,omitempty"`
	StartToken string    `json:"start_token,omitempty"`
	StartedAt  time.Time `json:"started_at"`
	Argv       []string  `json:"argv,omitempty"`
}

type LimitWindow = wire.LimitWindow

type Limits = wire.Limits

type LimitsReader interface {
	ReadLimits(ctx context.Context, q ModelQuery) (Limits, error)
}

type LoginOptions struct {
	// Provider is the model provider of a harness that has many, such as
	// OpenCode.
	Provider string
	// Separate is a login apart from the user's own login.
	Separate bool
}

type MCPCapability string

type MCPServer struct {
	Name    string
	Command string
	Args    []string
	Env     map[string]string
	URL     string
	Headers map[string]string
}

type ModelInfo struct {
	// ID is the value StartRequest.Model and SetModel take.
	ID string `json:"id"`
	// Name is the display name. Empty means use ID.
	Name string `json:"name,omitempty"`
	// Description is a short vendor note, such as the context size.
	Description string `json:"description,omitempty"`
	// Default marks the model the harness uses when Model is empty.
	Default bool `json:"default,omitempty"`
}

type ModelLister interface {
	Models(ctx context.Context, q ModelQuery) ([]ModelInfo, error)
}

type ModelQuery struct {
	Binary     string            // empty searches PATH
	Home       string            // same meaning as StartRequest.Home
	Env        map[string]string // same meaning as StartRequest.Env
	WorkingDir string            // some vendors read project config
}

type ModelSetter interface {
	SetModel(ctx context.Context, model string) error
}

type Options struct {
	// ClientName is the product name the harness sees in clientInfo and in
	// vendor client markers, for example "trebi" or "sling".
	ClientName string
	// ClientVersion is the product version reported next to ClientName.
	ClientVersion string
	// LedgerPath is the crash ledger file. Empty disables the ledger.
	LedgerPath string
	// Logger receives structured lifecycle lines. Nil discards them.
	Logger *slog.Logger
	// FingerprintIgnoreEnv lists environment keys left out of the OpenCode
	// server fingerprint, so per-run values do not split a shared server.
	FingerprintIgnoreEnv []string
	// MaxFrameBytes bounds one wire frame. Zero uses 16 MiB.
	MaxFrameBytes int
	// OnStderr receives live stderr lines from every child.
	OnStderr func(Harness, string)
	// AuthCacheTTL is how long a harness login probe answers from cache.
	// Zero uses 5 min. A negative value disables the cache.
	AuthCacheTTL time.Duration
	// ModelCacheTTL is how long a model list answers from cache. Zero uses
	// 10 min. A negative value disables the cache.
	ModelCacheTTL time.Duration
	// HTTPClient makes the release lookups of LatestVersion. Nil uses a
	// client with a 10 s timeout.
	HTTPClient *http.Client
}

type Permission = wire.Permission

type PermissionMode string

type PermissionPolicy struct {
	Mode PermissionMode
	// AllowTools lists extra tools that are allowed without asking, in "ask"
	// and "auto_edit" mode. Patterns may end in "*", for example
	// "mcp__sling__*".
	AllowTools []string
}

type Prompt = wire.Prompt

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

type Result = wire.Result

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

type Sender interface {
	Send(ctx context.Context, p Prompt) (Delivery, error)
}

type Session interface {
	// Provider is the harness name.
	Provider() string
	// ID is the vendor session id; it may be empty until init.
	ID() string
	// PID is the child process id (0 for in-process sessions).
	PID() int
	// Prompt writes one user turn.
	Prompt(ctx context.Context, p Prompt) error
	// Interrupt asks the harness to stop the current turn.
	Interrupt(ctx context.Context) error
	// AnswerPermission routes a decision to the vendor.
	AnswerPermission(ctx context.Context, permissionID string, d Decision) error
	// InterruptTurn is the protocol-level interrupt. It is the same call as
	// Interrupt for every built-in driver, and is kept for callers that want
	// to be explicit about not falling back to a signal.
	InterruptTurn(ctx context.Context) error
	// Done is closed when the session has ended and Events is drained.
	Done() <-chan struct{}
	// Err is the first failure the session recorded, if any.
	Err() error
	// Close runs the graceful close sequence and waits for the drain.
	Close(ctx context.Context) error
	// Events is closed after the terminal events.
	Events() <-chan Event
}

type SessionModels interface {
	Models() []ModelInfo
}

type SessionStatus = wire.SessionStatus

type Skill struct {
	// Name overrides the name in the SKILL.md frontmatter.
	Name string
	// Dir is the absolute path of the directory that holds SKILL.md.
	Dir string
}

type SkillSupport string

type Snapshot struct {
	State         SessionStatus
	TurnActive    bool
	Progressing   bool
	Stalled       bool
	StallSince    time.Time
	InflightTools int
	OpenApprovals int
	LastEventAt   time.Time
	LastEventKind EventType
	LastToolName  string
	IdleSince     time.Time
	WaitingSince  time.Time
	LastResult    *Result
	// Exited reports that the session's process ended.
	Exited bool
	// ExitedAt is the moment the exit event landed.
	ExitedAt time.Time
}

type StartRequest struct {
	Harness Harness
	// Binary is the executable. Empty searches PATH.
	Binary     string
	WorkingDir string
	// Env is added to the parent environment and wins on conflict.
	Env map[string]string
	// Home is an optional isolated config home. Empty uses the user's own
	// configuration, including their login, MCP servers and skills.
	Home string

	// SessionID is a resume target, or a pre-assigned id where the harness
	// allows one.
	SessionID string
	// Model is the vendor model name. Empty uses the vendor default.
	Model string
	// Effort is one of low, medium, high, max. Empty uses the vendor default.
	Effort string

	Permissions  PermissionPolicy
	MCPServers   []MCPServer
	Skills       []Skill
	Instructions string

	// Credentials carries the provider credentials for the native harness
	// only. The library never reads env or secrets to fill it, and the CLI
	// drivers ignore it.
	Credentials *Credentials

	// OneShot writes OneShotPrompt and closes stdin, so the child exits after
	// the turn. Use it for a job with no follow-up surface.
	OneShot       bool
	OneShotPrompt string
	// HandshakeTimeout overrides the protocol handshake wait.
	HandshakeTimeout time.Duration

	// ExtraArgs is appended verbatim after the library's own arguments. Use
	// it for consumer flags such as --settings or -c notify=...
	ExtraArgs []string
	// BaseCommand is an expert override: when it is set the launch builder is
	// skipped and the command is used as-is.
	BaseCommand []string
	// Raw carries per-harness overrides the typed fields do not cover:
	// "strict_mcp" (bool, Claude), "acp_auth_method" (string), "approvalPolicy"
	// and "sandbox" (string, Codex), "auth_method" (string, ACP).
	Raw map[string]any

	// LogPath writes the frames in and out as NDJSON. Secrets are not
	// redacted, so the file is created mode 0600. Stream fragments that a
	// later complete frame repeats are left out unless LogFragments is set.
	LogPath string
	// FragmentLogPath gets the buffered fragments of the open message when
	// the stream fails or ends before the complete message. Empty drops them.
	FragmentLogPath string
	// LogFragments writes every stream fragment to LogPath (debug).
	LogFragments bool
	// FS is the optional ACP file-system adapter.
	FS FileSystem
	// OnStderr receives live stderr lines from this child.
	OnStderr func(Harness, string)
}

type Steerer interface {
	Steer(ctx context.Context, p Prompt) error
}

type ToolEvent = wire.ToolEvent

type ToolKind = wire.ToolKind

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

type Usage = wire.Usage