react

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

type AgentMode uint8

type AgentModelBuilder interface {
	// Build a model for the agent.
	// A struct may be passed as the response type for a json schema, or it may be nil.
	// The stream callbacks may also be nil.
	BuildAgentModel(responseType any, onInitFinalStream func(), onDataFinalStream func(string)) jpf.Model
}

type AvailableToolDefinition struct {
	Name        string
	Description []string
}

type FragmentSelectorModelBuilder interface {
	// Build a model for a fragment selector.
	// A struct may be passed as the response type for a json schema, or it may be nil.
	BuildFragmentSelectorModel(responseType any) jpf.Model
}

type InsertedSkill struct {
	Skill
	NowRemainFor int
}

type Message interface {
	// contains filtered or unexported methods
}

type MessageStreamer interface {
	// Try to send a message, ignoring errors.
	TrySendMessage(msg Message)
}

type ModelBuilder interface {
	AgentModelBuilder
	FragmentSelectorModelBuilder
}

type NewOpt func(*newKwargs)

type Notification struct {
	Kind    string
	Content string
}

type SendMessageOpt func(*sendMessageKwargs)

type SerialisedMessage struct {
	Kind             SerialisedMessageKind     `json:"kind"`
	Content          string                    `json:"content,omitempty"`
	Reasoning        string                    `json:"reasoning,omitempty"`
	NotificationKind string                    `json:"notification_kind,omitempty"`
	ToolCalls        []ToolCall                `json:"tool_calls,omitempty"`
	Responses        []ToolResponse            `json:"responses,omitempty"`
	Skills           []InsertedSkill           `json:"skills,omitempty"`
	AvailableTools   []AvailableToolDefinition `json:"available_tools,omitempty"`
	Mode             AgentMode                 `json:"mode,omitempty"`
	Personality      string                    `json:"personality,omitempty"`
}

type SerialisedMessageKind string

type Skill struct {
	// A sensible snake_case key
	Key string
	// When should this be applied? If empty will always be applied.
	When string
	// The content that is not seen by the selector but is seen by the agent when chosen.
	Content string
	// How many turns after the turn it is inserted will the skill remain in context
	RemainFor int
}

type SkillSelector interface {
	// Select any relevant [Skill]s that should be added to the conversation.
	SelectSkills([]Skill, []Message) ([]Skill, error)
}

type TextStreamer interface {
	// Try to send a response text chunk back, ignoring errors.
	TrySendTextChunk(chunk string)
}

type Tool interface {
	// The name of the tool to be used by the agent. Should probably be snake_case.
	Name() string
	// Describe the tool in short bullet points to the agent.
	// Includes which parameters to provide.
	// Parameters can be described as any json type.
	Description() []string
	// Call the tool, providing a formatted response or an error if the tool call failed.
	// The values of the args will be the direct result of json decoding the tool call args.
	Call(map[string]any) (string, error)
}

type ToolCall struct {
	ToolName string
	ToolArgs []ToolCallArg
}

type ToolCallArg struct {
	ArgName  string
	ArgValue any
}

type ToolResponse struct {
	Response string
}