pkg

package
v1.14.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 25, 2025 License: AGPL-3.0 Imports: 24 Imported by: 0

README

Hector

A fresh, clean implementation of Hector built natively on the A2A (Agent-to-Agent) protocol.

Overview

Hector is a complete rewrite that follows the architectural patterns from Google's ADK-Go, with clean interfaces and native A2A protocol support.

Key Features
  • Native A2A: Uses github.com/a2aproject/a2a-go directly, no custom protobuf
  • Interface-First: All core components are defined as interfaces for testability
  • Iterator Pattern: Uses Go 1.23+ iter.Seq2 for clean event streaming
  • Context Hierarchy: Clear separation of read-only vs mutable context
  • Lazy Loading: Toolsets connect to external services on first use

Package Structure

v2/
├── agent/                    # Core agent interfaces and types
│   ├── agent.go             # Agent interface and base implementation
│   ├── context.go           # Context hierarchy (Invocation/Readonly/Callback)
│   ├── event.go             # Event types for agent communication
│   └── llmagent/            # LLM-based agent implementation
│       ├── llmagent.go      # LLM agent with tool calling support
│       └── context.go       # Tool execution context
├── model/                    # LLM interface
│   └── model.go             # LLM abstraction for different providers
├── runner/                   # Agent orchestration
│   └── runner.go            # Manages agent execution within sessions
├── server/                   # A2A protocol server
│   ├── executor.go          # a2asrv.AgentExecutor implementation
│   ├── events.go            # Event translation (Hector ↔ A2A)
│   └── parts.go             # Part conversion utilities
├── session/                  # Session management
│   └── session.go           # Session interface and in-memory impl
├── tool/                     # Tool interfaces
│   └── tool.go              # Tool, Toolset, and predicate patterns
└── examples/                 # Usage examples
    └── quickstart/          # Simple echo agent example

Quick Start

package main

import (
    "github.com/verikod/hector/pkg/agent"
    "github.com/verikod/hector/pkg/agent/llmagent"
    "github.com/verikod/hector/pkg/runner"
    "github.com/verikod/hector/pkg/server"
    "github.com/verikod/hector/pkg/session"
)

func main() {
    // Create an LLM agent
    myAgent, _ := llmagent.New(llmagent.Config{
        Name:        "assistant",
        Model:       myLLM, // Your model implementation
        Instruction: "You are a helpful assistant.",
        Tools:       []tool.Tool{myTool},
    })

    // Set up the runner
    runnerCfg := runner.Config{
        AppName:        "my-app",
        Agent:          myAgent,
        SessionService: session.InMemoryService(),
    }

    // Create A2A server
    executor := server.NewExecutor(server.ExecutorConfig{
        RunnerConfig: runnerCfg,
    })

    // Serve via JSON-RPC
    handler := a2asrv.NewHandler(executor)
    http.Handle("/a2a", a2asrv.NewJSONRPCHandler(handler))
    http.ListenAndServe(":8080", nil)
}

Architecture

Context Hierarchy
InvocationContext (full access)
    └── CallbackContext (state modification)
            └── ReadonlyContext (safe for tools)
Event Flow
User Message
    ↓
Runner.Run()
    ↓
Agent.Run() → yields Event(s)
    ↓
Session.AppendEvent()
    ↓
A2A Event Translation
    ↓
Client Response

Migration from v1

The v2 package is designed to coexist with the legacy pkg/ during migration:

  1. New features: Implement in v2
  2. Existing features: Gradually port to v2
  3. Legacy code: Remains functional in pkg/
Key Differences
v1 (pkg/) v2
Custom protobuf (pb.Message) Native a2a-go types (a2a.Message)
Channel-based streaming Iterator-based (iter.Seq2)
Monolithic Agent struct Interface-based composition
Eager tool loading Lazy toolset resolution

Contributing

When adding new features:

  1. Define interfaces first
  2. Implement concrete types
  3. Add tests alongside implementation
  4. Follow existing patterns from ADK-Go

License

AGPL-3.0 (non-commercial); commercial licensing available per LICENSE.md

Documentation

Overview

Package pkg provides a config-first AI agent platform with a clean programmatic API.

Hector can be used in three ways:

Config-First (Primary)

Load agents from YAML configuration: 

h, err := pkg.FromConfig("config.yaml")
if err != nil {
    log.Fatal(err)
}
defer h.Close()

// Start A2A server
h.Serve(":8080")

Programmatic API (Simple)

Build a single agent programmatically: 

h, err := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithMCPTool("weather", "http://localhost:9000"),
    pkg.WithInstruction("You are a helpful assistant."),
)
if err != nil {
    log.Fatal(err)
}
defer h.Close()

response, err := h.Generate(ctx, "How is the weather in Berlin?")

Multi-Agent Patterns

Hector supports two multi-agent patterns aligned with adk-go:

Pattern 1 - Transfer (sub-agents take over): 

// Create specialized agents
researcher, _ := pkg.NewAgent(llmagent.Config{
    Name:        "researcher",
    Description: "Researches topics in depth",
    Model:       model,
})
writer, _ := pkg.NewAgent(llmagent.Config{
    Name:        "writer",
    Description: "Writes content based on research",
    Model:       model,
})

// Create parent with sub-agents (transfer tools auto-created)
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithSubAgents(researcher, writer),
)

Pattern 2 - Delegation (parent maintains control): 

// Create specialized agents
searchAgent, _ := pkg.NewAgent(llmagent.Config{
    Name:        "web_search",
    Description: "Searches the web for information",
    Model:       model,
})

// Create parent that uses agent as a tool
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithAgentTool(searchAgent),  // Parent calls searchAgent, gets results back
)

Or use the helper function directly: 

searchTool := pkg.AgentAsTool(searchAgent)
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithTool(searchTool),
)

Package pkg is Hector, built natively on the A2A (Agent-to-Agent) protocol using the a2a-go library.

Architecture Overview

Hector follows a clean, interface-driven architecture inspired by Google's ADK-Go, with the following core concepts:

  • Agent: The fundamental unit of execution, implementing the Agent interface
  • Session: Manages conversation state and history
  • Tool/Toolset: Capabilities that agents can invoke
  • Runner: Orchestrates agent execution within sessions
  • Server: Exposes agents via A2A protocol (JSON-RPC, gRPC, HTTP)

Key Design Principles

  • Native A2A: Uses github.com/a2aproject/a2a-go directly, no custom protobuf
  • Interface-First: All core components are defined as interfaces for testability
  • Iterator Pattern: Uses Go 1.23+ iter.Seq2 for clean event streaming
  • Context Hierarchy: Clear separation of read-only vs mutable context
  • Lazy Loading: Toolsets connect to external services on first use

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FindAgentPath 

func FindAgentPath(root Agent, name string) []string

FindAgentPath returns the path to an agent in the tree. The path is a slice of agent names from root to the target. Returns nil if the agent is not found.

func WalkAgents 

func WalkAgents(root Agent, visitor func(Agent, int) bool)

WalkAgents visits all agents in the tree depth-first. The visitor function is called for each agent with its depth level.

Example: 

pkg.WalkAgents(root, func(ag pkg.Agent, depth int) bool {
    fmt.Printf("%s%s\n", strings.Repeat("  ", depth), ag.Name())
    return true // continue walking
})

Types

type Agent 

type Agent = agent.Agent

Agent is the core agent interface.

func FindAgent 

func FindAgent(root Agent, name string) Agent

FindAgent searches for an agent by name in the agent tree. This provides the same functionality as ADK-Go's find_agent() method.

Example: 

root, _ := pkg.NewAgent(llmagent.Config{
    Name: "coordinator",
    SubAgents: []pkg.Agent{researcher, writer},
})

found := pkg.FindAgent(root, "researcher")
if found != nil {
    // Use the found agent
}

func ListAgents 

func ListAgents(root Agent) []Agent

ListAgents returns a flat list of all agents in the tree.

func NewAgent 

func NewAgent(cfg llmagent.Config) (Agent, error)

NewAgent creates a new LLM agent programmatically. This is the recommended way to create agents for multi-agent patterns.

Example: 

model, _ := openai.New(openai.Config{APIKey: key})
agent, _ := pkg.NewAgent(pkg.AgentOptions{
    Name:        "researcher",
    Description: "Researches topics",
    Model:       model,
    Tools:       []tool.Tool{searchTool},
})

func NewLoopAgent 

func NewLoopAgent(cfg LoopConfig) (Agent, error)

NewLoopAgent creates an agent that runs sub-agents repeatedly.

Runs sub-agents in sequence for N iterations or until escalation. Set MaxIterations=0 for indefinite looping until escalation.

Use this for iterative refinement workflows, such as:

  • Code review and improvement cycles
  • Content revision loops
  • Optimization iterations

Example: 

reviewer, _ := pkg.NewAgent(llmagent.Config{Name: "reviewer", Model: model, ...})
improver, _ := pkg.NewAgent(llmagent.Config{Name: "improver", Model: model, ...})

refiner, _ := pkg.NewLoopAgent(pkg.LoopConfig{
    Name:          "refiner",
    Description:   "Iteratively refines output",
    SubAgents:     []pkg.Agent{reviewer, improver},
    MaxIterations: 3,
})

func NewParallelAgent 

func NewParallelAgent(cfg ParallelConfig) (Agent, error)

NewParallelAgent creates an agent that runs sub-agents simultaneously.

All sub-agents receive the same input and run in parallel. Events from all sub-agents are yielded as they complete.

Use this for:

  • Running different algorithms simultaneously
  • Generating multiple responses for review
  • Getting diverse perspectives on a problem

Example: 

voter1, _ := pkg.NewAgent(llmagent.Config{Name: "voter1", Model: model, ...})
voter2, _ := pkg.NewAgent(llmagent.Config{Name: "voter2", Model: model, ...})
voter3, _ := pkg.NewAgent(llmagent.Config{Name: "voter3", Model: model, ...})

voters, _ := pkg.NewParallelAgent(pkg.ParallelConfig{
    Name:        "voters",
    Description: "Gets multiple perspectives",
    SubAgents:   []pkg.Agent{voter1, voter2, voter3},
})

func NewRemoteAgent 

func NewRemoteAgent(cfg RemoteAgentConfig) (Agent, error)

NewRemoteAgent creates a remote A2A agent.

Remote agents communicate with agents running in different processes or on different hosts using the A2A (Agent-to-Agent) protocol.

Remote agents can be:

  • Used as sub-agents for transfer patterns
  • Wrapped as tools using AgentAsTool()
  • Part of workflow agents (sequential, parallel, loop)

Example: 

// From URL (agent card resolved automatically)
remoteHelper, _ := pkg.NewRemoteAgent(pkg.RemoteAgentConfig{
    Name:        "remote_helper",
    Description: "A remote helper agent",
    URL:         "http://localhost:9000",
})

// Use as sub-agent
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithSubAgents(remoteHelper),
)

// Use as tool
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithAgentTool(remoteHelper),
)

func NewSequentialAgent 

func NewSequentialAgent(cfg SequentialConfig) (Agent, error)

NewSequentialAgent creates an agent that runs sub-agents once, in sequence.

Use this when you want execution to occur in a fixed, strict order, such as a processing pipeline.

Example: 

stage1, _ := pkg.NewAgent(llmagent.Config{Name: "stage1", Model: model, ...})
stage2, _ := pkg.NewAgent(llmagent.Config{Name: "stage2", Model: model, ...})
stage3, _ := pkg.NewAgent(llmagent.Config{Name: "stage3", Model: model, ...})

pipeline, _ := pkg.NewSequentialAgent(pkg.SequentialConfig{
    Name:        "pipeline",
    Description: "Processes data through multiple stages",
    SubAgents:   []pkg.Agent{stage1, stage2, stage3},
})

type AgentConfig 

type AgentConfig = config.AgentConfig

AgentConfig is the configuration for an agent.

type CallableTool 

type CallableTool = tool.CallableTool

CallableTool is a tool that can be called synchronously.

type Event 

type Event = agent.Event

Event represents an agent event.

type Hector 

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

Hector is the main entry point for the Hector platform. It wraps a runtime.Runtime and provides a clean API.

func FromConfig 

func FromConfig(path string) (*Hector, error)

FromConfig creates a Hector instance from a config file.

func FromConfigWithContext 

func FromConfigWithContext(ctx context.Context, path string) (*Hector, error)

FromConfigWithContext creates a Hector instance from a config file with context.

func New 

func New(opts ...Option) (*Hector, error)

New creates a Hector instance programmatically. All options are converted to config and run through the same runtime as FromConfig.

func (*Hector) Agent 

func (h *Hector) Agent(name string) (agent.Agent, bool)

Agent returns an agent by name.

func (*Hector) Close 

func (h *Hector) Close() error

Close releases all resources.

func (*Hector) Config 

func (h *Hector) Config() *config.Config

Config returns the loaded configuration.

func (*Hector) DefaultAgent 

func (h *Hector) DefaultAgent() (agent.Agent, bool)

DefaultAgent returns the default agent.

func (*Hector) Generate 

func (h *Hector) Generate(ctx context.Context, input string) (string, error)

Generate produces a response for the given input. This is a convenience method for simple single-turn interactions.

func (*Hector) GenerateStream 

func (h *Hector) GenerateStream(ctx context.Context, input string) iter.Seq2[*agent.Event, error]

GenerateStream produces a streaming response.

func (*Hector) Run 

func (h *Hector) Run(ctx context.Context, input string) iter.Seq2[*agent.Event, error]

Run executes the agent and streams events.

func (*Hector) RunWithSession 

func (h *Hector) RunWithSession(ctx context.Context, userID, sessionID, input string) iter.Seq2[*agent.Event, error]

RunWithSession executes the agent with a specific session.

func (*Hector) Runtime 

func (h *Hector) Runtime() *runtime.Runtime

Runtime returns the underlying runtime.

func (*Hector) Serve 

func (h *Hector) Serve(addr string) error

Serve starts the A2A server.

func (*Hector) SessionService 

func (h *Hector) SessionService() session.Service

SessionService returns the session service.

type LLM 

type LLM = model.LLM

LLM is the LLM interface.

type LLMAgentConfig 

type LLMAgentConfig = llmagent.Config

LLMAgentConfig is the configuration for an LLM agent.

type LLMAgentReasoningConfig 

type LLMAgentReasoningConfig = llmagent.ReasoningConfig

LLMAgentReasoningConfig configures the reasoning loop for LLM agents.

type LLMConfig 

type LLMConfig = config.LLMConfig

LLMConfig is the configuration for an LLM.

type LoopConfig 

type LoopConfig = workflowagent.LoopConfig

LoopConfig is the configuration for a loop agent.

type Option 

type Option func(*builder) error

Option configures a Hector instance.

func WithAgent 

func WithAgent(name string, cfg *config.AgentConfig) Option

WithAgent adds a custom agent configuration.

func WithAgentName 

func WithAgentName(name string) Option

WithAgentName sets the default agent name.

func WithAgentTool 

func WithAgentTool(ag agent.Agent) Option

WithAgentTool adds an agent as a callable tool (Pattern 2: delegation). The parent agent maintains control and receives structured results.

This follows the adk-go agenttool pattern where the sub-agent runs in an isolated session and returns results to the parent.

Example: 

searchAgent, _ := llmagent.New(llmagent.Config{
    Name:        "web_search",
    Description: "Searches the web for information",
    Model:       model,
})

h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithAgentTool(searchAgent),  // Parent can call web_search tool
)

func WithAgentTools 

func WithAgentTools(agents ...agent.Agent) Option

WithAgentTools adds multiple agents as callable tools. Convenience wrapper for adding multiple agent tools at once.

Example: 

h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithAgentTools(searchAgent, analysisAgent, writerAgent),
)

func WithAnthropic 

func WithAnthropic(acfg anthropic.Config) Option

WithAnthropic configures Anthropic as the LLM provider.

func WithControlTools 

func WithControlTools(enableExit, enableEscalate bool) Option

WithControlTools enables control flow tools for explicit loop termination. When enabled, the agent can call exit_loop to signal completion or escalate to delegate to a parent agent.

Example: 

pkg.WithControlTools(true, true)  // Enable both exit and escalate

func WithGemini 

func WithGemini(gcfg gemini.Config) Option

WithGemini configures Gemini as the LLM provider.

func WithInstruction 

func WithInstruction(instruction string) Option

WithInstruction sets the system instruction for the default agent.

func WithLLM 

func WithLLM(llm model.LLM) Option

WithLLM configures a custom LLM instance. This bypasses the factory and uses the provided LLM directly.

func WithLLMConfig 

func WithLLMConfig(name string, cfg *config.LLMConfig) Option

WithLLMConfig adds an LLM from config.

func WithMCPCommand 

func WithMCPCommand(name, command string, args ...string) Option

WithMCPCommand adds an MCP toolset using stdio transport.

func WithMCPTool 

func WithMCPTool(name, url string, filter ...string) Option

WithMCPTool adds an MCP toolset using SSE transport.

func WithMCPToolHTTP 

func WithMCPToolHTTP(name, url string, filter ...string) Option

WithMCPToolHTTP adds an MCP toolset using streamable-http transport. Use this for Composio and other HTTP-based MCP servers.

func WithOllama 

func WithOllama(ocfg ollama.Config) Option

WithOllama configures Ollama as the LLM provider. Ollama runs locally and doesn't require an API key.

func WithOpenAI 

func WithOpenAI(ocfg openai.Config) Option

WithOpenAI configures OpenAI as the LLM provider.

func WithReasoning 

func WithReasoning(cfg *config.ReasoningConfig) Option

WithReasoning configures the chain-of-thought reasoning loop. This controls how the agent iterates through tool calls and responses.

Example: 

pkg.WithReasoning(&config.ReasoningConfig{
    MaxIterations:      50,
    EnableExitTool:     true,
    EnableEscalateTool: true,
})

func WithSessionService 

func WithSessionService(s session.Service) Option

WithSessionService sets a custom session service.

func WithStreaming 

func WithStreaming(enabled bool) Option

WithStreaming enables token-by-token streaming for the default agent.

func WithSubAgents 

func WithSubAgents(agents ...agent.Agent) Option

WithSubAgents adds sub-agents for automatic transfer (Pattern 1). Transfer tools are automatically created for each sub-agent, allowing the parent agent to hand off control when needed.

This follows the adk-go transfer pattern where the parent agent stops and the sub-agent takes over completely.

Example: 

researcher, _ := llmagent.New(llmagent.Config{Name: "researcher", ...})
writer, _ := llmagent.New(llmagent.Config{Name: "writer", ...})

h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithSubAgents(researcher, writer),
)

The agent will have transfer_to_researcher and transfer_to_writer tools.

func WithTool 

func WithTool(t tool.Tool) Option

WithTool adds a single tool directly. Use this when you have a tool.Tool implementation ready to use.

Example: 

myTool := &MyCustomTool{}
h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithTool(myTool),
)

func WithToolConfig 

func WithToolConfig(name string, cfg *config.ToolConfig) Option

WithToolConfig adds a tool from config.

func WithTools 

func WithTools(tools ...tool.Tool) Option

WithTools adds multiple tools directly. Convenience wrapper for adding multiple tools at once.

Example: 

h, _ := pkg.New(
    pkg.WithOpenAI(openai.Config{APIKey: key}),
    pkg.WithTools(tool1, tool2, tool3),
)

func WithToolset 

func WithToolset(ts tool.Toolset) Option

WithToolset adds a custom toolset.

type ParallelConfig 

type ParallelConfig = workflowagent.ParallelConfig

ParallelConfig is the configuration for a parallel agent.

type ReasoningConfig 

type ReasoningConfig = config.ReasoningConfig

ReasoningConfig configures the reasoning loop.

type RemoteAgentConfig 

type RemoteAgentConfig = remoteagent.Config

RemoteAgentConfig is the configuration for a remote A2A agent.

type SequentialConfig 

type SequentialConfig = workflowagent.SequentialConfig

SequentialConfig is the configuration for a sequential agent.

type Tool 

type Tool = tool.Tool

Tool is the core tool interface.

func AgentAsTool 

func AgentAsTool(ag Agent) Tool

AgentAsTool converts an agent to a tool (Pattern 2: delegation). The parent agent maintains control and receives structured results.

Example: 

searchTool := pkg.AgentAsTool(searchAgent)
parentAgent, _ := pkg.NewAgent(pkg.AgentOptions{
    Tools: []tool.Tool{searchTool},
})

func AgentAsToolWithConfig 

func AgentAsToolWithConfig(ag Agent, cfg *agenttool.Config) Tool

AgentAsToolWithConfig converts an agent to a tool with configuration.

func EscalateTool 

func EscalateTool() Tool

EscalateTool creates a tool for escalating to parent agent.

func ExitLoopTool 

func ExitLoopTool() Tool

ExitLoopTool creates a tool for explicit loop termination.

func TransferTool 

func TransferTool(agentName, description string) Tool

TransferTool creates a tool for transferring to another agent.

type ToolConfig 

type ToolConfig = config.ToolConfig

ToolConfig is the configuration for a tool.

type Toolset 

type Toolset = tool.Toolset

Toolset groups related tools.

Source Files

View all Source files

Directories

Path Synopsis
Package agent defines the core agent interfaces and types for Hector v2.
 Package agent defines the core agent interfaces and types for Hector v2.
llmagent
Package llmagent provides an LLM-based agent implementation for Hector v2.
 Package llmagent provides an LLM-based agent implementation for Hector v2.
remoteagent
Package remoteagent provides remote A2A agent support.
 Package remoteagent provides remote A2A agent support.
runneragent
Package runneragent provides a deterministic tool execution agent.
 Package runneragent provides a deterministic tool execution agent.
workflowagent
Package workflowagent provides workflow agents for orchestrating multi-agent flows.
 Package workflowagent provides workflow agents for orchestrating multi-agent flows.
Package auth provides authentication and authorization for Hector v2.
 Package auth provides authentication and authorization for Hector v2.
Package builder provides fluent builder APIs for programmatic agent construction.
 Package builder provides fluent builder APIs for programmatic agent construction.
Package checkpoint provides execution state capture and recovery.
 Package checkpoint provides execution state capture and recovery.
Package config provides configuration loading and management for Hector v2.
 Package config provides configuration loading and management for Hector v2.
provider
Package provider defines the config source abstraction.
 Package provider defines the config source abstraction.
Package embedder provides text embedding services for semantic search.
 Package embedder provides text embedding services for semantic search.
examples
programmatic command
Example programmatic demonstrates the comprehensive programmatic API of Hector.
 Example programmatic demonstrates the comprehensive programmatic API of Hector.
weather command
Example weather demonstrates using Hector with MCP tools.
 Example weather demonstrates using Hector with MCP tools.
Package guardrails provides composable safety controls for Hector agents.
 Package guardrails provides composable safety controls for Hector agents.
input
output
tool
Package httpclient provides an HTTP client with retry, backoff, and rate limit handling.
 Package httpclient provides an HTTP client with retry, backoff, and rate limit handling.
Package instruction provides instruction templating for Hector v2 agents.
 Package instruction provides instruction templating for Hector v2 agents.
Package model defines the LLM interface for Hector v2.
 Package model defines the LLM interface for Hector v2.
anthropic
Package anthropic provides an Anthropic Claude LLM implementation.
 Package anthropic provides an Anthropic Claude LLM implementation.
gemini
Package gemini implements the model.LLM interface for Google Gemini models.
 Package gemini implements the model.LLM interface for Google Gemini models.
ollama
Package ollama provides an Ollama LLM implementation.
 Package ollama provides an Ollama LLM implementation.
openai
Package openai provides an OpenAI LLM implementation using the Responses API.
 Package openai provides an OpenAI LLM implementation using the Responses API.
Package observability provides OpenTelemetry tracing and Prometheus metrics.
 Package observability provides OpenTelemetry tracing and Prometheus metrics.
Package rag provides Retrieval-Augmented Generation (RAG) capabilities.
 Package rag provides Retrieval-Augmented Generation (RAG) capabilities.
Package ratelimit provides a comprehensive rate limiting system for Hector v2.
 Package ratelimit provides a comprehensive rate limiting system for Hector v2.
Package runner provides the orchestration layer for agent execution.
 Package runner provides the orchestration layer for agent execution.
Package runtime builds and manages Hector agents from configuration.
 Package runtime builds and manages Hector agents from configuration.
Package server provides the HTTP and gRPC server implementation for Hector.
 Package server provides the HTTP and gRPC server implementation for Hector.
Package session provides session management for Hector v2.
 Package session provides session management for Hector v2.
Package task provides task management for Hector v2.
 Package task provides task management for Hector v2.
Package tool defines interfaces for tools that agents can invoke.
 Package tool defines interfaces for tools that agents can invoke.
agenttool
Package agenttool provides a tool that allows an agent to call another agent.
 Package agenttool provides a tool that allows an agent to call another agent.
approvaltool
Package approvaltool provides a Human-in-the-Loop (HITL) tool example.
 Package approvaltool provides a Human-in-the-Loop (HITL) tool example.
commandtool
Package commandtool provides a secure, streaming command execution tool.
 Package commandtool provides a secure, streaming command execution tool.
controltool
Package controltool provides control flow tools for agent reasoning loops.
 Package controltool provides control flow tools for agent reasoning loops.
filetool
functiontool
Package functiontool provides a convenient way to create tools from typed Go functions.
 Package functiontool provides a convenient way to create tools from typed Go functions.
mcptoolset
Package mcptoolset provides a Toolset implementation for MCP servers.
 Package mcptoolset provides a Toolset implementation for MCP servers.
searchtool
Package searchtool provides a search tool for agents to query document stores.
 Package searchtool provides a search tool for agents to query document stores.
todotool
webtool
Package trigger provides scheduled and event-driven agent invocation.
 Package trigger provides scheduled and event-driven agent invocation.
Package utils provides utility functions for v2.
 Package utils provides utility functions for v2.
Package vector provides a unified interface for vector database operations.
 Package vector provides a unified interface for vector database operations.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.