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 HostTier ¶

type HostTier struct{}

HostTier 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 (HostTier) Tier() ipc.Tier

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() ipc.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, HostTier or NetworkTier, 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() ipc.Tier

type NetworkTier ¶

type NetworkTier struct{}

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

func (NetworkTier) Tier() ipc.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)