internal

type ACPProfileExecutor ¶

type ACPProfileExecutor interface {
	RunACPProfile(ctx context.Context, request ACPRunRequest) (*RunResult, error)
}

ACPProfileExecutor executes ACP stdio profile runs behind an internal boundary.

type ACPRunRequest ¶

type ACPRunRequest struct {
	ProfileName string
	Profile     *ap.AgentProfile
	Model       string
	UserID      string
	SessionID   string
	Message     *MessageContent
}

ACPRunRequest describes a resolved profile run for ACP stdio execution.

type AgentExecError ¶

type AgentExecError struct {
	Kind AgentExecErrorKind
	Op   string
	Err  error
}

AgentExecError wraps agent execution dispatch failures with a stable kind and operation.

func (e *AgentExecError) Error() string

func (e *AgentExecError) Unwrap() error

type AgentExecErrorKind ¶

type AgentExecErrorKind string

AgentExecErrorKind classifies agent execution dispatch failures.

const (
	// AgentExecErrorKindValidation indicates invalid input for a dispatch operation.
	AgentExecErrorKindValidation AgentExecErrorKind = "validation"
	// AgentExecErrorKindNotFound indicates the requested profile does not exist.
	AgentExecErrorKindNotFound AgentExecErrorKind = "not-found"
	// AgentExecErrorKindUnsupported indicates the selected execution mode is not supported.
	AgentExecErrorKindUnsupported AgentExecErrorKind = "unsupported"
	// AgentExecErrorKindExecution indicates a lower-level dependency failed during dispatch.
	AgentExecErrorKindExecution AgentExecErrorKind = "execution"
)

type AgentRunner ¶

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

func (a *AgentRunner) ListSessions(
	ctx context.Context,
	params ListSessionMetadataParams,
) (*ListSessionMetadataResult, error)

func (a *AgentRunner) ReadSession(ctx context.Context, params ReadSessionParams) (*ReadSessionResult, error)

func (a *AgentRunner) Run(ctx context.Context, params RunParams) (*RunResult, error)

type AgentRunnerFactory ¶

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

func NewAgentRunnerFactory(deps AgentRunnerFactoryDeps) *AgentRunnerFactory

func (f *AgentRunnerFactory) ListSessions(
	ctx context.Context,
	params ListSessionMetadataParams,
) (*ListSessionMetadataResult, error)

func (f *AgentRunnerFactory) NewAgentRunner(ctx context.Context, params NewAgentRunnerParams) (*AgentRunner, error)

func (f *AgentRunnerFactory) ReadSession(ctx context.Context, params ReadSessionParams) (*ReadSessionResult, error)

type AgentRunnerFactoryDeps ¶

type AgentRunnerFactoryDeps struct {
	LLMAdapterFactory     LLMAdapterFactory
	LLMAgentFactory       LLMAgentFactory
	LLMAgentRunnerFactory LLMAgentRunnerRunFactory
	SessionStorage        sessions.SessionsStorage
	RootLogger            *slog.Logger
}

type BackgroundRunner ¶

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

BackgroundRunner wraps an underlying runner and executes runs in background goroutines decoupled from the caller's context. It provides fan-out via EventBus and supports reconnection via ReadSession.

func NewBackgroundRunner(deps BackgroundRunnerDeps) *BackgroundRunner

func (br *BackgroundRunner) ListSessions(
	ctx context.Context,
	params ListSessionMetadataParams,
) (*ListSessionMetadataResult, error)

func (br *BackgroundRunner) ReadSession(
	ctx context.Context,
	params ReadSessionParams,
) (*ReadSessionResult, error)

func (br *BackgroundRunner) Run(ctx context.Context, params RunParams) (*RunResult, error)

func (br *BackgroundRunner) Shutdown()

type BackgroundRunnerDeps ¶

type BackgroundRunnerDeps struct {
	Runner backgroundRunnerDep
	Logger *slog.Logger
}

BackgroundRunnerDeps holds the dependencies for NewBackgroundRunner.

type ConsumeOption ¶

type ConsumeOption func(*consumeOptions)

ConsumeOption is a functional option for ConsumeEventsAsString.

func WithAgentName(name string) ConsumeOption

func WithEmptyResultBehavior(b EmptyResultBehavior) ConsumeOption

func WithResultSelection(s ResultSelection) ConsumeOption

type EmptyResultBehavior ¶

type EmptyResultBehavior int

EmptyResultBehavior controls what happens when no content is found in the event stream.

const (
	EmptyResultBehaviorReturnError EmptyResultBehavior = iota
	EmptyResultBehaviorReturnEmpty
)

type EventBus ¶

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

EventBus is a replay-capable broadcast mechanism for a single run's events. Every event published is stored in an internal buffer AND forwarded to all live subscriber channels. Late subscribers can replay all buffered events without any gap, because the buffer copy and channel registration happen atomically under the same lock.

func NewEventBus() *EventBus

func (b *EventBus) Close(err error)

func (b *EventBus) Done() <-chan struct{}

func (b *EventBus) Publish(event *SessionEvent)

func (b *EventBus) ReplayAndSubscribe(ctx context.Context) iter.Seq2[*SessionEvent, error]

func (b *EventBus) Subscribe() (int, <-chan *SessionEvent)

func (b *EventBus) Unsubscribe(id int)

type FakeGenkitInstance ¶

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

FakeGenkitInstance is a test helper that provides a controllable genkit init function. Each call to the returned InitFunc increments an internal counter and returns a zero *genkit.Genkit. Access InitCount() to inspect how many times the init function was called.

func NewFakeGenkitInstance() *FakeGenkitInstance

func (f *FakeGenkitInstance) InitCount() int

func (f *FakeGenkitInstance) InitFunc() func(context.Context, lp.ProviderConfig) (*genkit.Genkit, error)

type GenkitLLMAdapterDeps ¶

type GenkitLLMAdapterDeps struct {
	Genkit     *genkit.Genkit
	RootLogger *slog.Logger
	// contains filtered or unexported fields
}

GenkitLLMAdapterDeps holds dependencies for constructing the adapter.

type GenkitLLMAdapterFactory ¶

type GenkitLLMAdapterFactory func(name string) model.LLM

GenkitLLMAdapterFactory is a function that creates a GenkitLLMAdapter for a resolved model name.

func NewGenkitLLMAdapterFactory(deps GenkitLLMAdapterDeps) GenkitLLMAdapterFactory

type LLMAdapterFactory ¶

type LLMAdapterFactory func(ctx context.Context, modelName string) (model.LLM, error)

LLMAdapterFactory creates a model.LLM from a model name. Callers may pass an empty name when the factory ignores it (e.g. tests); the exported agent.Runner requires a non-empty RunParams.Model and does not substitute a runner-level default. The context MUST be the same as the run (e.g. passed to NewAgentRunner) so cancellation and request-scoped values propagate to model resolution. On failure the LLM must be nil and err non-nil (never return a nil LLM without an error).

type LLMAgentFactory ¶

type LLMAgentFactory func(cfg llmagent.Config) (agent.Agent, error)

LLMAgentFactory creates an agent.Agent from a llmagent.Config.

type LLMAgentRunnerRunFactory ¶

type LLMAgentRunnerRunFactory func(cfg runner.Config) (*runner.Runner, error)

LLMAgentRunnerRunFactory creates a runner.Runner from runner.Config.

type LLMRunner ¶

type LLMRunner interface {
	Run(
		ctx context.Context,
		userID, sessionID string,
		msg *genai.Content,
		cfg agent.RunConfig,
		opts ...runner.RunOption,
	) iter.Seq2[*session.Event, error]
}

LLMRunner executes an agent run and yields session events. Compatible with runner.Runner.Run; *runner.Runner implements this interface directly.

type ListSessionMetadataParams ¶

type ListSessionMetadataParams = sessions.ListSessionMetadataParams

ListSessionMetadataParams is an alias for sessions.ListSessionMetadataParams.

type ListSessionMetadataResult ¶

type ListSessionMetadataResult = sessions.ListSessionMetadataResult

ListSessionMetadataResult is an alias for sessions.ListSessionMetadataResult.

type MessageContent ¶

type MessageContent struct {
	Parts []MessagePart
}

MessageContent is a minimal representation of an inbound user message.

type MessagePart ¶

type MessagePart struct {
	Text string
}

MessagePart is a single segment of MessageContent; only text is supported for now.

type ModelInfo ¶

type ModelInfo struct {
	// Provider is the provider name (prefix in fully-qualified model names).
	Provider string

	// Name is the technical model identifier (e.g., "gpt-4.1").
	Name string

	// DisplayName is an optional human-friendly label.
	DisplayName string
}

ModelInfo describes a single model available through a provider.

type ModelsLocator ¶

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

ModelsLocator resolves model.LLM adapters from fully-qualified model names and caches genkit instances per provider. Cache invalidation is based on UpdatedAt.

func NewModelsLocator(params ModelsLocatorParams) *ModelsLocator

func (l *ModelsLocator) ListModels(ctx context.Context) ([]ModelInfo, error)

func (l *ModelsLocator) ResolveModel(
	ctx context.Context,
	fqModelName string,
) (model.LLM, error)

type ModelsLocatorParams ¶

type ModelsLocatorParams struct {
	ProvidersSvc      lp.ProvidersConfigService
	Logger            *slog.Logger
	GenkitInitFunc    genkitInitFuncType   // injectable; defaults to defaultGenkitInit
	ToolStubRegistrar func(*genkit.Genkit) // required; called on each new genkit instance
}

ModelsLocatorParams holds dependencies for constructing a ModelsLocator.

type NewAgentRunnerParams ¶

type NewAgentRunnerParams struct {
	AppName               string
	AgentName             string
	SystemPromptFragments []SystemPromptFragment
	ToolsRegistry         ToolsProvider
	ModelName             string // from RunParams; public Runner validates non-empty before NewAgentRunner

	// Profile execution fields — required when AgentRunner.Run should handle profile dispatch.
	DefaultAgentName   string
	ProfilesService    profilesService
	ACPProfileExecutor ACPProfileExecutor
}

type ReadSessionParams ¶

type ReadSessionParams struct {
	AppName   string
	SessionID string
	UserID    string
}

ReadSessionParams contains the parameters for reading a session.

type ReadSessionResult ¶

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

ReadSessionResult is the result of reading a session: identifier, whether a background run is active (only when using BackgroundRunner), and a replayable event stream.

func NewReadSessionResult(sessionID string, isActive bool, events iter.Seq2[*SessionEvent, error]) *ReadSessionResult

func (r *ReadSessionResult) Events() iter.Seq2[*SessionEvent, error]

func (r *ReadSessionResult) IsActive() bool

func (r *ReadSessionResult) SessionID() string

type ResultSelection ¶

type ResultSelection int

ResultSelection controls how multiple final (or partial) events with content are combined.

const (
	ResultSelectionConcatenateAll ResultSelection = iota
	ResultSelectionLastOnly
)

type RunParams ¶

type RunParams struct {
	UserID    string
	SessionID string
	Message   *MessageContent
	Model     string // fully qualified: "provider/model-name"
	// ProfileName selects a saved profile for profile-backed execution.
	// Empty means direct built-in execution using Model.
	ProfileName string
}

type RunResult ¶

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

func NewRunResult(events iter.Seq2[*SessionEvent, error], sessionID string) *RunResult

func (r *RunResult) ConsumeEventsAsString(ctx context.Context, opts ...ConsumeOption) (string, error)

func (r *RunResult) ConsumeEventsAsStringSeq(ctx context.Context) iter.Seq2[string, error]

func (r *RunResult) Events() iter.Seq2[*SessionEvent, error]

func (r *RunResult) SessionID() string

type SessionEvent ¶

type SessionEvent struct {
	ErrorCode    string
	ErrorMessage string
	Partial      bool
	TurnComplete bool
	Interrupted  bool
	Author       string
	Branch       string
	InvocationID string
	Content      *SessionEventContent
}

SessionEvent is a projection of ADK session.Event fields consumed by RunResult and the agent API stream mapper.

func MapADKSessionEvent(ev *session.Event) *SessionEvent

type SessionEventContent ¶

type SessionEventContent struct {
	Role  string
	Parts []SessionEventPart
}

SessionEventContent is a text-only projection of model message content on session events (no genai types).

type SessionEventFunctionCall ¶

type SessionEventFunctionCall struct {
	ID   string
	Name string
	Args map[string]any
}

SessionEventFunctionCall holds the tool invocation requested by the model.

type SessionEventFunctionResponse ¶

type SessionEventFunctionResponse struct {
	ID       string
	Name     string
	Response map[string]any
}

SessionEventFunctionResponse holds the result returned by a tool invocation.

type SessionEventPart ¶

type SessionEventPart struct {
	Text             string
	FunctionCall     *SessionEventFunctionCall
	FunctionResponse *SessionEventFunctionResponse
}

SessionEventPart is one segment in streamed session-event content (not agent input; see MessagePart). Exactly one of Text, FunctionCall, or FunctionResponse is set per part.

type SessionMetadata ¶

type SessionMetadata = sessions.SessionMetadata

SessionMetadata is an alias for sessions.SessionMetadata.

type SessionMetadataStore ¶

type SessionMetadataStore = sessions.SessionMetadataStore

SessionMetadataStore is an alias for sessions.SessionMetadataStore.

type StaticToolsProvider ¶

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

StaticToolsProvider returns a fixed set of tools.

func StaticTools(tools []tool.Tool) *StaticToolsProvider

func (s *StaticToolsProvider) GetTools() ([]tool.Tool, error)

type SystemPromptFragment ¶

type SystemPromptFragment struct {
	// Section is a short title rendered as a second-level heading.
	Section string
	// Content is the body; may use markdown (use third-level headings for subsections).
	Content string
}

SystemPromptFragment is a section appended after the base system prompt template. The agent package re-exports this type as SystemPromptFragment.

type SystemPromptInstructionProviderOption ¶

type SystemPromptInstructionProviderOption func(*systemPromptInstructionProviderConfig)

SystemPromptInstructionProviderOption configures newSystemPromptInstructionProvider.

func WithSystemPromptBaseTemplate(s string) SystemPromptInstructionProviderOption

type ToolsProvider ¶

type ToolsProvider interface {
	GetTools() ([]tool.Tool, error)
}

ToolsProvider supplies tools for an agent. Implemented by *aitools.ToolsRegistry.