model

type AmbiguousProposalError ¶

type AmbiguousProposalError struct {
	Provider string
	Count    int
}

AmbiguousProposalError reports more proposed actions than the caller can admit for one decision.

func (failure *AmbiguousProposalError) Error() string

type IAgentAddress ¶

type IAgentAddress interface {
	// Provider names the provider that owns this address type.
	Provider() string
	// Key identifies the session uniquely across providers and tiers. It is
	// the address's stable identity in registries, inboxes and logs.
	Key() string
	// Tier is how far a message to this address travels from the runtime
	// that holds the inbox.
	Tier() io.Tier
	// contains filtered or unexported methods
}

IAgentAddress is where one agent's live conversation session receives messages. Each provider declares its own address types beside its brain, under ipc/model/<provider>, because what identifies a session is the provider's to say: a Claude Code session is a session identifier plus the local socket it is reached on, a Copilot session is a session identifier reached through the Copilot provider.

The tier is part of the address's TYPE, not a field: every address type embeds exactly one of InProcessTier, IpcTier or NetTier, and the interface is closed by an unexported method only those three markers carry. That makes it a sealed sum type over the three tiers: an address that a caller built as in-process cannot be routed through a socket, because no value of its type answers any other tier.

type IBrain ¶

type IBrain[Context any, Action any] interface {
	// Propose returns the actions the brain proposes for decision. A proposal
	// is never permission to execute it.
	Propose(ctx context.Context, decision Context) (*Proposal[Action], error)
}

IBrain is an agent loop over a large model behind an inference provider. Context is the information supplied for one decision; Action is what the brain may propose. Both are type parameters, so a caller never holds an untyped value at this boundary.

type InProcessTier ¶

type InProcessTier struct{}

InProcessTier marks an address whose session runs in the same runtime: a direct call or a channel reaches it, with no capability.

func (InProcessTier) Tier() io.Tier

type IpcTier ¶

type IpcTier struct{}

IpcTier marks an address whose session runs in another process on the same machine, reached through an ipc capability (a unix socket, or loopback through ipc/net).

func (IpcTier) Tier() io.Tier

type NetTier ¶

type NetTier struct{}

NetTier marks an address whose session runs on another machine, reached through ipc/net.

func (NetTier) Tier() io.Tier

type Proposal ¶

type Proposal[Action any] struct {
	// Provider names the inference provider that produced the proposal.
	Provider string
	// Actions are the proposed actions in the order the brain gave them.
	Actions []Action
}

Proposal is a brain's answer for one decision. It is data, not an authorization: the caller decides whether any action is admitted.

func (proposal *Proposal[Action]) Only() (Action, error)

type TurnReport ¶

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

TurnReport writes one turn's structured log: a trace per turn, a span per event. When the caller's context already carries a trace, the turn is a child span of it; otherwise the turn starts a new W3C trace. One goroutine at a time writes a report.

func NewTurnReport(ctx context.Context, logger *slog.Logger, provider string, session uuid.UUID, turn int) (*TurnReport, error)

func (report *TurnReport) Diagnostics(stderr []byte)

func (report *TurnReport) Event(direction string, kind string, raw json.RawMessage)

func (report *TurnReport) Finished(events int, err error)

func (report *TurnReport) Malformed(line int, size int, err error)

func (report *TurnReport) Started(executable string, resume bool, inputs int)