config

package
v0.2.7 Latest Latest
Warning

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

 Go to latest Published: Apr 21, 2026 License: MIT Imports: 22 Imported by: 1

Documentation

Overview

Package config

Example: Using Security Configuration

## Overview

The security configuration feature allows you to separate sensitive data (API keys, tokens, secrets, passwords) from your main configuration. The system automatically loads values from `.security.yml` and applies them to the corresponding fields in your config.

**Key Points:** - Values from `.security.yml` are automatically mapped to config fields - No `ref:` syntax is needed - just omit sensitive fields from config.json - If a field exists in both files, `.security.yml` value takes precedence - You can mix direct values in config.json with security values

## 1. Create .security.yml

File: ~/.picoclaw/.security.yml

```yaml # Model API Keys # All models MUST use 'api_keys' (plural) array format # Even a single key must be provided as an array with one element model_list: 

gpt-5.4:
  api_keys:
    - "sk-proj-your-actual-openai-key-1"
    - "sk-proj-your-actual-openai-key-2"  # Optional: Multiple keys for failover
claude-sonnet-4.6:
  api_keys:
    - "sk-ant-your-actual-anthropic-key"  # Single key in array format

# Channel Tokens channels: 

telegram:
  token: "1234567890:ABCdefGHIjklMNOpqrsTUVwxyz"
discord:
  token: "your-discord-bot-token"

# Web Tool Keys # Brave, Tavily, Perplexity: Use 'api_keys' array # GLMSearch, BaiduSearch: Use 'api_key' single string web: 

brave:
  api_keys:
    - "BSAyour-brave-api-key-1"
    - "BSAyour-brave-api-key-2"  # Optional: Multiple keys for failover
tavily:
  api_keys:
    - "tvly-your-tavily-api-key"  # Single key in array format
perplexity:
  api_keys:
    - "pplx-your-perplexity-api-key"  # Single key in array format
glm_search:
  api_key: "your-glm-search-api-key"  # Single key (not array)
baidu_search:
  api_key: "your-baidu-search-api-key"  # Single key (not array)

```

## 2. Simplify config.json

File: ~/.picoclaw/config.json

Note: Sensitive fields are omitted because they're loaded from .security.yml

```json 

{
  "version": 1,
  "agents": {
    "defaults": {
      "workspace": "~/picoclaw-workspace",
      "model_name": "gpt-5.4"
    }
  },
  "model_list": [
    {
      "model_name": "gpt-5.4",
      "model": "openai/gpt-5.4",
      "api_base": "https://api.openai.com/v1"
      // api_key is automatically loaded from .security.yml
    },
    {
      "model_name": "claude-sonnet-4.6",
      "model": "anthropic/claude-sonnet-4.6",
      "api_base": "https://api.anthropic.com/v1"
      // api_key is automatically loaded from .security.yml
    }
  ],
  "channels": {
    "telegram": {
      "enabled": true
      // token is automatically loaded from .security.yml
    },
    "discord": {
      "enabled": true
      // token is automatically loaded from .security.yml
    }
  },
  "tools": {
    "web": {
      "brave": {
        "enabled": true
        // api_key is automatically loaded from .security.yml
      },
      "tavily": {
        "enabled": true
        // api_key is automatically loaded from .security.yml
      },
      "glm_search": {
        "enabled": true
        // api_key is automatically loaded from .security.yml
      },
      "baidu_search": {
        "enabled": true
        // api_key is automatically loaded from .security.yml
      }
    }
  }
}

```

## 3. Set proper permissions

```bash chmod 600 ~/.picoclaw/.security.yml ```

## 4. Add to .gitignore

```gitignore # Security configuration .security.yml ```

## 5. Verify it works

```bash picoclaw --version ```

Supported Fields in .security.yml

## Model API Keys

All models MUST use the `api_keys` (plural) array format in .security.yml.

```yaml model_list: 

<model_name>:
  api_keys:
    - "key-1"
    - "key-2"  # Optional: Multiple keys for failover

```

Examples: ```yaml model_list: 

gpt-5.4:
  api_keys:
    - "sk-proj-key-1"
    - "sk-proj-key-2"
claude-sonnet-4.6:
  api_keys:
    - "sk-ant-key"

```

**Important:** - Always use `api_keys` (plural) for models - Even a single key must be in an array format - The model_name in .security.yml must match the model_name in config.json

## Channel Tokens/Secrets

```yaml channels: 

telegram:
  token: "value"
feishu:
  app_secret: "value"
  encrypt_key: "value"
  verification_token: "value"
discord:
  token: "value"
weixin:
  token: "value"
qq:
  app_secret: "value"
dingtalk:
  client_secret: "value"
slack:
  bot_token: "value"
  app_token: "value"
matrix:
  access_token: "value"
line:
  channel_secret: "value"
  channel_access_token: "value"
onebot:
  access_token: "value"
wecom:
  token: "value"
  encoding_aes_key: "value"
wecom_app:
  corp_secret: "value"
  token: "value"
  encoding_aes_key: "value"
wecom_aibot:
  secret: "value"
  token: "value"
  encoding_aes_key: "value"
pico:
  token: "value"
irc:
  password: "value"
  nickserv_password: "value"
  sasl_password: "value"

## Web Tool API Keys

**Brave, Tavily, Perplexity:** ```yaml web: 

brave:
  api_keys:
    - "BSA-key-1"
    - "BSA-key-2"
tavily:
  api_keys:
    - "tvly-key"
perplexity:
  api_keys:
    - "pplx-key"

``` Use `api_keys` (plural) array format.

**GLMSearch, BaiduSearch:** ```yaml web: 

glm_search:
  api_key: "your-glm-key"
baidu_search:
  api_key: "your-baidu-key"

``` Use `api_key` (singular) single string format.

## Skills Registry Tokens

```yaml skills: 

github:
  token: "value"
clawhub:
  auth_token: "value"

```

Backward Compatibility

You can still use direct values in config.json if needed:

```json 

{
  "model_list": [
    {
      "model_name": "local-model",
      "model": "ollama/llama3",
      "api_base": "http://localhost:11434/v1",
      "api_key": "ollama"  // Direct value (works fine)
    }
  ]
}

```

You can also mix security values and direct values:

```json 

{
  "model_list": [
    {
      "model_name": "cloud-model",
      // api_key loaded from .security.yml
    },
    {
      "model_name": "local-model",
      "model": "ollama/llama3",
      "api_base": "http://localhost:11434/v1",
      "api_key": "ollama"  // Direct value
    }
  ]
}

```

**Priority Order:** 1. Environment variables (highest priority) 2. .security.yml values 3. config.json direct values (lowest priority)

Migration from Old Config

## Step 1: Backup your config ```bash cp ~/.picoclaw/config.json ~/.picoclaw/config.json.backup ```

## Step 2: Create .security.yml ```bash cp security.example.yml ~/.picoclaw/.security.yml ```

## Step 3: Fill in your API keys Edit ~/.picoclaw/.security.yml and replace placeholders with your actual keys.

## Step 4: Simplify config.json (Recommended) Remove sensitive fields from ~/.picoclaw/config.json: - `api_key` fields from model_list entries - `token` fields from channels - `api_key` fields from tools.web - `token`/`auth_token` fields from tools.skills

## Step 5: Set permissions ```bash chmod 600 ~/.picoclaw/.security.yml ```

## Step 6: Test ```bash picoclaw --version ```

If everything works, you can delete the backup: ```bash rm ~/.picoclaw/config.json.backup ```

Advanced Features

## Multiple API Keys (Load Balancing & Failover)

You can configure multiple API keys for models and web tools to enable: - **Load balancing**: Requests are distributed across multiple keys - **Failover**: If a key fails, the system automatically switches to another key - **Rate limit management**: Distribute usage across multiple keys - **High availability**: Reduce downtime during API provider issues

### Example: Model with Multiple Keys

**.security.yml:** ```yaml model_list: 

gpt-5.4:
  api_keys:
    - "sk-proj-key-1"
    - "sk-proj-key-2"
    - "sk-proj-key-3"

```

**config.json:** ```json 

{
  "model_list": [
    {
      "model_name": "gpt-5.4",
      "model": "openai/gpt-5.4",
      "api_base": "https://api.openai.com/v1"
    }
  ]
}

```

### Example: Web Tool with Multiple Keys

**.security.yml:** ```yaml web: 

brave:
  api_keys:
    - "BSA-key-1"
    - "BSA-key-2"
tavily:
  api_keys:
    - "tvly-your-key"  # Single key in array format
glm_search:
  api_key: "your-glm-key"  # GLMSearch uses single key format

```

**config.json:** ```json 

{
  "tools": {
    "web": {
      "brave": {
        "enabled": true
      },
      "tavily": {
        "enabled": true
      },
      "glm_search": {
        "enabled": true
      }
    }
  }
}

```

## Single Key Format

**Models, Brave, Tavily, Perplexity:** ```yaml model_list: 

gpt-5.4:
  api_keys:
    - "sk-proj-your-key"  # Single key in array format

```

**GLMSearch, BaiduSearch:** ```yaml web: 

glm_search:
  api_key: "your-glm-key"  # Single key (not array)

```

## Model Name Matching

The system supports intelligent model name matching in .security.yml:

### Example 1: Exact Match

**config.json:** ```json 

{
  "model_name": "gpt-5.4:0"
}

```

**.security.yml (exact match with index):** ```yaml model_list: 

gpt-5.4:0:
  api_keys: ["key-1"]

```

### Example 2: Base Name Match

**config.json:** ```json 

{
  "model_name": "gpt-5.4:0"
}

```

**.security.yml (base name without index):** ```yaml model_list: 

gpt-5.4:
  api_keys: ["key-1", "key-2"]

```

Both methods work. The base name match allows you to use simpler keys in .security.yml even when your config uses indexed model names for load balancing.

## Security File Permissions

The security file should have restricted permissions:

```bash chmod 600 ~/.picoclaw/.security.yml ```

This ensures only the owner can read and write the file.

Security Best Practices

1. Never commit .security.yml to version control 2. Add .security.yml to your .gitignore file 3. Set file permissions: chmod 600 ~/.picoclaw/.security.yml 4. Use different keys for different environments (dev, staging, production) 5. Rotate keys regularly and update .security.yml 6. Encrypt backups containing .security.yml 7. Review access regularly

Environment Variables

You can override any security value using environment variables:

```bash # Channels export PICOCLAW_CHANNELS_TELEGRAM_TOKEN="token-from-env" export PICOCLAW_CHANNELS_DISCORD_TOKEN="discord-token-from-env"

# Web Tools export PICOCLAW_TOOLS_WEB_BRAVE_API_KEY="brave-key-from-env" export PICOCLAW_TOOLS_WEB_BAIDU_API_KEY="baidu-key-from-env"

# Skills export PICOCLAW_TOOLS_SKILLS_GITHUB_TOKEN="github-token-from-env" ```

Environment variables have the highest priority and will override both config.json and .security.yml values.

Troubleshooting

## Error: "failed to load security config" - Ensure .security.yml exists in the same directory as config.json - Check YAML syntax is valid (use a YAML validator) - Verify file permissions allow reading

## Error: "model security entry not found" - Check that the model name in config.json matches exactly in .security.yml - Verify the model_list section exists in .security.yml - For indexed names (e.g., "gpt-5.4:0"), check both exact match and base name match - Ensure the YAML structure is correct (proper indentation)

## Multiple API Keys Not Working - Ensure you're using `api_keys` (plural) in .security.yml for models and web tools (except GLMSearch/BaiduSearch) - Check that the array format is correct in YAML (proper indentation with dashes) - Remember: Models, Brave, Tavily, Perplexity MUST use `api_keys` (array format) - GLMSearch and BaiduSearch MUST use `api_key` (single string format)

## Keys Not Being Applied - Check that .security.yml is in the same directory as config.json - Verify the file permissions allow reading (chmod 600 ~/.picoclaw/.security.yml) - Ensure the YAML structure matches the expected format - Check for typos in field names (case-sensitive) - Verify the model/channel names match exactly (case-sensitive)

## Load Balancing/Failover Issues - Verify all API keys in the api_keys array are valid - Check that all keys have the same rate limits and permissions - Monitor logs to see which keys are being used and failing - Ensure the api_keys array is properly formatted in YAML

Index

Constants

View Source 
const (
	ReadFileModeBytes = "bytes"
	ReadFileModeLines = "lines"
)
View Source 
const (
	ChannelPico           = "pico"
	ChannelPicoClient     = "pico_client"
	ChannelTelegram       = "telegram"
	ChannelDiscord        = "discord"
	ChannelFeishu         = "feishu"
	ChannelWeixin         = "weixin"
	ChannelWeCom          = "wecom"
	ChannelDingTalk       = "dingtalk"
	ChannelSlack          = "slack"
	ChannelMatrix         = "matrix"
	ChannelLINE           = "line"
	ChannelOneBot         = "onebot"
	ChannelQQ             = "qq"
	ChannelIRC            = "irc"
	ChannelVK             = "vk"
	ChannelMaixCam        = "maixcam"
	ChannelWhatsApp       = "whatsapp"
	ChannelWhatsAppNative = "whatsapp_native"
	ChannelTeamsWebHook   = "teams_webhook"
)

Channel type constants — single source of truth for all channel type names.

View Source 
const (
	// EnvHome overrides the base directory for all picoclaw data
	// (config, workspace, skills, auth store, …).
	// Default: ~/.picoclaw
	EnvHome = "PICOCLAW_HOME"

	// EnvConfig overrides the full path to the JSON config file.
	// Default: $PICOCLAW_HOME/config.json
	EnvConfig = "PICOCLAW_CONFIG"

	// EnvBuiltinSkills overrides the directory from which built-in
	// skills are loaded.
	// Default: <cwd>/skills
	EnvBuiltinSkills = "PICOCLAW_BUILTIN_SKILLS"

	// EnvBinary overrides the path to the picoclaw executable.
	// Used by the web launcher when spawning the gateway subprocess.
	// Default: resolved from the same directory as the current executable.
	EnvBinary = "PICOCLAW_BINARY"

	// EnvGatewayHost overrides the host address for the gateway server.
	// Default: "localhost"
	EnvGatewayHost = "PICOCLAW_GATEWAY_HOST"
)

Runtime environment variable keys for the picoclaw process. These control the location of files and binaries at runtime and are read directly via os.Getenv / os.LookupEnv. All picoclaw-specific keys use the PICOCLAW_ prefix. Reference these constants instead of inline string literals to keep all supported knobs visible in one place and to prevent typos.

View Source 
const CurrentVersion = 3

CurrentVersion is the latest config schema version

View Source 
const DefaultGatewayLogLevel = "warn"
View Source 
const DefaultMCPMaxInlineTextChars = 16 * 1024
View Source 
const DefaultMaxMediaSize = 20 * 1024 * 1024 // 20 MB
View Source 
const (
	SecurityConfigFile = ".security.yml"
)

Variables

View Source 
var (
	Version   = "dev" // Default value when not built with ldflags
	GitCommit string  // Git commit SHA (short)
	BuildTime string  // Build timestamp in RFC3339 format
	GoVersion string  // Go version used for building
)

Build-time variables injected via ldflags during build process. These are set by the Makefile or .goreleaser.yaml using the -X flag: 

-X github.com/sipeed/picoclaw/pkg/config.Version=<version>
-X github.com/sipeed/picoclaw/pkg/config.GitCommit=<commit>
-X github.com/sipeed/picoclaw/pkg/config.BuildTime=<timestamp>
-X github.com/sipeed/picoclaw/pkg/config.GoVersion=<go-version>
View Source 
var BaseFieldNames = map[string]struct{}{
	"enabled":              {},
	"type":                 {},
	"allow_from":           {},
	"reasoning_channel_id": {},
	"group_trigger":        {},
	"typing":               {},
	"placeholder":          {},
}

BaseFieldNames are JSON keys that belong to Channel, not to channel-specific settings.

Functions

func EffectiveGatewayLogLevel added in v0.2.5 

func EffectiveGatewayLogLevel(cfg *Config) string

EffectiveGatewayLogLevel returns the normalized runtime log level from a loaded config. Invalid or empty values fall back to the package default.

func FormatBuildInfo added in v0.2.2 

func FormatBuildInfo() (string, string)

FormatBuildInfo returns build time and go version info

func FormatVersion added in v0.2.2 

func FormatVersion() string

FormatVersion returns the version string with optional git commit

func GetHome added in v0.2.5 

func GetHome() string

func GetVersion added in v0.2.2 

func GetVersion() string

GetVersion returns the version string

func InitChannelList added in v0.2.7 

func InitChannelList(channels ChannelsConfig) error

InitChannelList validates and initializes all channels in the ChannelsConfig. It performs three steps:

  1. Validates that each channel has a non-empty Type
  2. Validates singleton constraints
  3. Decodes Settings into the correct typed struct based on Type, so that b.extend contains the actual settings (e.g., PicoSettings)

After calling this method, callers can safely use b.extend via Decode() without re-parsing raw Settings.

func IsSingletonChannel added in v0.2.7 

func IsSingletonChannel(channelType string) bool

IsSingletonChannel returns true if the channel type only allows one instance.

func ResolveGatewayLogLevel added in v0.2.5 

func ResolveGatewayLogLevel(path string) string

ResolveGatewayLogLevel reads the configured gateway log level without triggering the full config loader, so startup code can apply logging before config load logs run. The PICOCLAW_LOG_LEVEL environment variable overrides the file value.

func SaveConfig 

func SaveConfig(path string, cfg *Config) error

Types

type AgentConfig added in v0.2.0 

type AgentConfig struct {
	ID        string            `json:"id"`
	Default   bool              `json:"default,omitempty"`
	Name      string            `json:"name,omitempty"`
	Workspace string            `json:"workspace,omitempty"`
	Model     *AgentModelConfig `json:"model,omitempty"`
	Skills    []string          `json:"skills,omitempty"`
	Subagents *SubagentsConfig  `json:"subagents,omitempty"`
}

type AgentDefaults 

type AgentDefaults struct {
	Workspace                 string             `json:"workspace"                        env:"PICOCLAW_AGENTS_DEFAULTS_WORKSPACE"`
	RestrictToWorkspace       bool               `json:"restrict_to_workspace"            env:"PICOCLAW_AGENTS_DEFAULTS_RESTRICT_TO_WORKSPACE"`
	AllowReadOutsideWorkspace bool               `json:"allow_read_outside_workspace"     env:"PICOCLAW_AGENTS_DEFAULTS_ALLOW_READ_OUTSIDE_WORKSPACE"`
	Provider                  string             `json:"provider"                         env:"PICOCLAW_AGENTS_DEFAULTS_PROVIDER"`
	ModelName                 string             `json:"model_name"                       env:"PICOCLAW_AGENTS_DEFAULTS_MODEL_NAME"`
	ModelFallbacks            []string           `json:"model_fallbacks,omitempty"`
	ImageModel                string             `json:"image_model,omitempty"            env:"PICOCLAW_AGENTS_DEFAULTS_IMAGE_MODEL"`
	ImageModelFallbacks       []string           `json:"image_model_fallbacks,omitempty"`
	MaxTokens                 int                `json:"max_tokens"                       env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOKENS"`
	ContextWindow             int                `json:"context_window,omitempty"         env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_WINDOW"`
	Temperature               *float64           `json:"temperature,omitempty"            env:"PICOCLAW_AGENTS_DEFAULTS_TEMPERATURE"`
	MaxToolIterations         int                `json:"max_tool_iterations"              env:"PICOCLAW_AGENTS_DEFAULTS_MAX_TOOL_ITERATIONS"`
	SummarizeMessageThreshold int                `json:"summarize_message_threshold"      env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_MESSAGE_THRESHOLD"`
	SummarizeTokenPercent     int                `json:"summarize_token_percent"          env:"PICOCLAW_AGENTS_DEFAULTS_SUMMARIZE_TOKEN_PERCENT"`
	MaxMediaSize              int                `json:"max_media_size,omitempty"         env:"PICOCLAW_AGENTS_DEFAULTS_MAX_MEDIA_SIZE"`
	Routing                   *RoutingConfig     `json:"routing,omitempty"`
	SteeringMode              string             `json:"steering_mode,omitempty"          env:"PICOCLAW_AGENTS_DEFAULTS_STEERING_MODE"`      // "one-at-a-time" (default) or "all"
	MaxParallelTurns          int                `json:"max_parallel_turns,omitempty"     env:"PICOCLAW_AGENTS_DEFAULTS_MAX_PARALLEL_TURNS"` // Max concurrent turns (0 or 1 = sequential)
	SubTurn                   SubTurnConfig      ``                                                                                          /* 145-byte string literal not displayed */
	ToolFeedback              ToolFeedbackConfig `json:"tool_feedback,omitempty"`
	SplitOnMarker             bool               `json:"split_on_marker"                  env:"PICOCLAW_AGENTS_DEFAULTS_SPLIT_ON_MARKER"` // split messages on <|[SPLIT]|> marker
	ContextManager            string             `json:"context_manager,omitempty"        env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER"`
	ContextManagerConfig      json.RawMessage    `json:"context_manager_config,omitempty" env:"PICOCLAW_AGENTS_DEFAULTS_CONTEXT_MANAGER_CONFIG"`
}

func (*AgentDefaults) GetMaxMediaSize added in v0.2.1 

func (d *AgentDefaults) GetMaxMediaSize() int

func (*AgentDefaults) GetModelName added in v0.2.0 

func (d *AgentDefaults) GetModelName() string

GetModelName returns the effective model name for the agent defaults. It prefers the new "model_name" field but falls back to "model" for backward compatibility.

func (*AgentDefaults) GetToolFeedbackMaxArgsLength added in v0.2.4 

func (d *AgentDefaults) GetToolFeedbackMaxArgsLength() int

GetToolFeedbackMaxArgsLength returns the max args preview length for tool feedback messages.

func (*AgentDefaults) IsToolFeedbackEnabled added in v0.2.4 

func (d *AgentDefaults) IsToolFeedbackEnabled() bool

IsToolFeedbackEnabled returns true when tool feedback messages should be sent to the chat.

type AgentModelConfig added in v0.2.0 

type AgentModelConfig struct {
	Primary   string   `json:"primary,omitempty"`
	Fallbacks []string `json:"fallbacks,omitempty"`
}

AgentModelConfig supports both string and structured model config. String format: "gpt-4" (just primary, no fallbacks) Object format: {"primary": "gpt-4", "fallbacks": ["claude-haiku"]}

func (AgentModelConfig) MarshalJSON added in v0.2.0 

func (m AgentModelConfig) MarshalJSON() ([]byte, error)

func (*AgentModelConfig) UnmarshalJSON added in v0.2.0 

func (m *AgentModelConfig) UnmarshalJSON(data []byte) error

type AgentsConfig 

type AgentsConfig struct {
	Defaults AgentDefaults   `json:"defaults"`
	List     []AgentConfig   `json:"list,omitempty"`
	Dispatch *DispatchConfig `json:"dispatch,omitempty"`
}

type BaiduSearchConfig added in v0.2.4 

type BaiduSearchConfig struct {
	Enabled    bool         `json:"enabled"          yaml:"-"                 env:"PICOCLAW_TOOLS_WEB_BAIDU_ENABLED"`
	APIKey     SecureString `json:"api_key,omitzero" yaml:"api_key,omitempty" env:"PICOCLAW_TOOLS_WEB_BAIDU_API_KEY"`
	BaseURL    string       `json:"base_url"         yaml:"-"                 env:"PICOCLAW_TOOLS_WEB_BAIDU_BASE_URL"`
	MaxResults int          `json:"max_results"      yaml:"-"                 env:"PICOCLAW_TOOLS_WEB_BAIDU_MAX_RESULTS"`
}

type BraveConfig added in v0.1.2 

type BraveConfig struct {
	Enabled    bool          `json:"enabled"           yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_BRAVE_ENABLED"`
	APIKeys    SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty" env:"PICOCLAW_TOOLS_WEB_BRAVE_API_KEYS"`
	MaxResults int           `json:"max_results"       yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_BRAVE_MAX_RESULTS"`
}

func (*BraveConfig) APIKey added in v0.1.2 

func (c *BraveConfig) APIKey() string

APIKey returns the Brave API key

func (*BraveConfig) SetAPIKey added in v0.2.4 

func (c *BraveConfig) SetAPIKey(key string)

SetAPIKey sets the Brave API key

func (*BraveConfig) SetAPIKeys added in v0.2.4 

func (c *BraveConfig) SetAPIKeys(keys []string)

type BuildInfo added in v0.2.2 

type BuildInfo struct {
	Version   string `json:"version"`
	GitCommit string `json:"git_commit"`
	BuildTime string `json:"build_time"`
	GoVersion string `json:"go_version"`
}

BuildInfo contains build-time version information

type BuiltinHookConfig added in v0.2.4 

type BuiltinHookConfig struct {
	Enabled  bool            `json:"enabled"`
	Priority int             `json:"priority,omitempty"`
	Config   json.RawMessage `json:"config,omitempty"`
}

type Channel added in v0.2.7 

type Channel struct {
	Enabled            bool                `json:"enabled"                 yaml:"-"`
	Type               string              `json:"type"                    yaml:"-"`
	AllowFrom          FlexibleStringSlice `json:"allow_from,omitempty"    yaml:"-"`
	ReasoningChannelID string              `json:"reasoning_channel_id"    yaml:"-"`
	GroupTrigger       GroupTriggerConfig  `json:"group_trigger,omitempty" yaml:"-"`
	Typing             TypingConfig        `json:"typing,omitempty"        yaml:"-"`
	Placeholder        PlaceholderConfig   `json:"placeholder,omitempty"   yaml:"-"`
	Settings           RawNode             `json:"settings,omitzero"       yaml:"settings,omitempty"`
	// contains filtered or unexported fields
}

Channel defines the common fields shared by all channel types. Channel-specific settings go into Settings (nested format only). The settings struct should use SecureString/SecureStrings for sensitive fields.

Decode stores the settings pointer internally; subsequent modifications to the decoded struct are automatically reflected in MarshalJSON/MarshalYAML.

MarshalJSON outputs nested format (common fields at top level, settings as sub-key). MarshalYAML outputs only secure fields (for .security.yml).

Standard Go JSON/YAML unmarshaling handles nested format correctly:

  • JSON: {"enabled": true, "type": "telegram", "settings": {"base_url": "..."}}
  • YAML: settings: {token: xxx} (for .security.yml)

func (Channel) CollectSensitiveValues added in v0.2.7 

func (b Channel) CollectSensitiveValues() []string

CollectSensitiveValues returns all sensitive string values from this Channel's decoded settings (extend). Used by the security filter system.

func (*Channel) Decode added in v0.2.7 

func (b *Channel) Decode(target any) error

Decode decodes the Settings node into the given target struct and stores the pointer internally. Subsequent modifications to the target are automatically reflected in MarshalJSON/MarshalYAML (no explicit Encode needed).

func (*Channel) GetDecoded added in v0.2.7 

func (b *Channel) GetDecoded() (any, error)

GetDecoded returns the previously decoded settings struct. If Decode hasn't been called yet, it lazily decodes using the channel Type prototype. Returns an error if decoding fails; the decoded value (possibly nil) is still returned so callers can distinguish between "not decoded" and "decode failed".

func (Channel) MarshalJSON added in v0.2.7 

func (b Channel) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for Channel. Outputs nested format: common fields at top level, channel-specific in "settings". Secure fields (SecureString/SecureStrings) are removed from settings output.

func (Channel) MarshalYAML added in v0.2.7 

func (b Channel) MarshalYAML() (any, error)

MarshalYAML implements yaml.ValueMarshaler for Channel. Outputs only secure fields in the Settings YAML (for .security.yml). If Decode was called, it serializes from the stored extend (reflecting any modifications); otherwise falls back to decoding Settings via the channel Type to extract secure fields.

func (*Channel) Name added in v0.2.7 

func (b *Channel) Name() string

Name returns the channel name.

func (*Channel) SetName added in v0.2.7 

func (b *Channel) SetName(name string)

SetName sets the channel name.

func (*Channel) SetSecretField added in v0.2.7 

func (b *Channel) SetSecretField(fieldName string, value SecureString)

SetSecretField sets a secure field value by field name in the Settings JSON. NOTE: This only operates on raw Settings. If Decode() has been called, prefer modifying the typed struct directly — MarshalJSON serializes from extend.

func (*Channel) SettingsIsEmpty added in v0.2.7 

func (b *Channel) SettingsIsEmpty() bool

SettingsIsEmpty returns true if Settings has not been populated.

func (*Channel) UnmarshalYAML added in v0.2.7 

func (b *Channel) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML implements yaml.Unmarshaler for Channel. Merges the YAML node into the existing Channel. Supports both nested format (settings: {...}) and flat format (token: xxx).

type ChannelsConfig 

type ChannelsConfig map[string]*Channel

ChannelsConfig maps channel name to its Channel configuration. Each Channel stores the full channel config in Settings and handles JSON/YAML serialization (removing/keeping secure fields automatically).

func (ChannelsConfig) Get added in v0.2.7 

func (c ChannelsConfig) Get(name string) *Channel

Get returns the Channel for the given channel name (map key), or nil if not found.

func (ChannelsConfig) GetByType added in v0.2.7 

func (c ChannelsConfig) GetByType(t string) *Channel

GetByType returns the Channel for the given channel type, or nil if not found.

func (ChannelsConfig) SetEnabled added in v0.2.7 

func (c ChannelsConfig) SetEnabled(name string, enabled bool) bool

SetEnabled sets the Enabled field on the Channel with the given name. Returns false if no channel with that name exists.

func (*ChannelsConfig) UnmarshalJSON added in v0.2.7 

func (c *ChannelsConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for ChannelsConfig. Sets the channel name from the map key after unmarshaling.

func (*ChannelsConfig) UnmarshalYAML added in v0.2.7 

func (c *ChannelsConfig) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML implements yaml.Unmarshaler for ChannelsConfig. This ensures that when loading security.yml, existing Channel instances are properly merged rather than replaced with new ones.

type Config 

type Config struct {
	// Config schema version for migration.
	Version   int             `json:"version"             yaml:"-"`
	Isolation IsolationConfig `json:"isolation,omitempty" yaml:"-"`
	Agents    AgentsConfig    `json:"agents"              yaml:"-"`
	Session   SessionConfig   `json:"session,omitempty"   yaml:"-"`
	Channels  ChannelsConfig  `json:"channel_list"        yaml:"channel_list"`
	ModelList SecureModelList `json:"model_list"          yaml:"model_list"` // New model-centric provider configuration
	Gateway   GatewayConfig   `json:"gateway"             yaml:"-"`
	Hooks     HooksConfig     `json:"hooks,omitempty"     yaml:"-"`
	Tools     ToolsConfig     `json:"tools"               yaml:",inline"`
	Heartbeat HeartbeatConfig `json:"heartbeat"           yaml:"-"`
	Devices   DevicesConfig   `json:"devices"             yaml:"-"`
	Voice     VoiceConfig     `json:"voice"               yaml:"-"`
	// BuildInfo contains build-time version information
	BuildInfo BuildInfo `json:"build_info,omitempty" yaml:"-"`
	// contains filtered or unexported fields
}

Config is the current config structure with version support.

func DefaultConfig 

func DefaultConfig() *Config

DefaultConfig returns the default configuration for PicoClaw.

func LoadConfig 

func LoadConfig(path string) (*Config, error)

func (*Config) FilterSensitiveData added in v0.2.4 

func (c *Config) FilterSensitiveData(content string) string

FilterSensitiveData filters sensitive values from content before sending to LLM. This prevents the LLM from seeing its own credentials. Uses strings.Replacer for O(n+m) performance (computed once per SecurityConfig). Short content (below FilterMinLength) is returned unchanged for performance.

func (*Config) GetModelConfig added in v0.2.0 

func (c *Config) GetModelConfig(modelName string) (*ModelConfig, error)

GetModelConfig returns the ModelConfig for the given model name. If multiple configs exist with the same model_name, it uses round-robin selection for load balancing. Returns an error if the model is not found.

func (*Config) MarshalJSON added in v0.2.0 

func (c *Config) MarshalJSON() ([]byte, error)

MarshalJSON implements custom JSON marshaling for Config to omit providers section when empty and session when empty.

func (*Config) SecurityCopyFrom added in v0.2.4 

func (c *Config) SecurityCopyFrom(path string) error

func (*Config) SensitiveDataReplacer added in v0.2.5 

func (sec *Config) SensitiveDataReplacer() *strings.Replacer

SensitiveDataReplacer returns the strings.Replacer for filtering sensitive data. It is computed once on first access via sync.Once.

func (*Config) ValidateModelList added in v0.2.0 

func (c *Config) ValidateModelList() error

ValidateModelList validates all ModelConfig entries in the model_list. It checks that each model config is valid. Note: Multiple entries with the same model_name are allowed for load balancing.

func (*Config) WorkspacePath 

func (c *Config) WorkspacePath() string

type CronToolsConfig added in v0.2.0 

type CronToolsConfig struct {
	ToolConfig         `     envPrefix:"PICOCLAW_TOOLS_CRON_"`
	ExecTimeoutMinutes int  `                                 json:"exec_timeout_minutes" env:"PICOCLAW_TOOLS_CRON_EXEC_TIMEOUT_MINUTES"` // 0 means no timeout
	AllowCommand       bool `                                 json:"allow_command"        env:"PICOCLAW_TOOLS_CRON_ALLOW_COMMAND"`
}

type DevicesConfig added in v0.1.2 

type DevicesConfig struct {
	Enabled    bool `json:"enabled"     env:"PICOCLAW_DEVICES_ENABLED"`
	MonitorUSB bool `json:"monitor_usb" env:"PICOCLAW_DEVICES_MONITOR_USB"`
}

type DingTalkSettings added in v0.2.7 

type DingTalkSettings struct {
	ClientID     string       `json:"client_id"              yaml:"-"                       env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_ID"`
	ClientSecret SecureString `json:"client_secret,omitzero" yaml:"client_secret,omitempty" env:"PICOCLAW_CHANNELS_DINGTALK_CLIENT_SECRET"`
}

type DiscordSettings added in v0.2.7 

type DiscordSettings struct {
	Token       SecureString `json:"token,omitzero" yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_DISCORD_TOKEN"`
	Proxy       string       `json:"proxy"          yaml:"-"               env:"PICOCLAW_CHANNELS_DISCORD_PROXY"`
	MentionOnly bool         `json:"mention_only"   yaml:"-"               env:"PICOCLAW_CHANNELS_DISCORD_MENTION_ONLY"`
}

type DispatchConfig added in v0.2.7 

type DispatchConfig struct {
	Rules []DispatchRule `json:"rules,omitempty"`
}

type DispatchRule added in v0.2.7 

type DispatchRule struct {
	Name              string           `json:"name,omitempty"`
	Agent             string           `json:"agent"`
	When              DispatchSelector `json:"when"`
	SessionDimensions []string         `json:"session_dimensions,omitempty"`
}

type DispatchSelector added in v0.2.7 

type DispatchSelector struct {
	Channel   string `json:"channel,omitempty"`
	Account   string `json:"account,omitempty"`
	Space     string `json:"space,omitempty"`
	Chat      string `json:"chat,omitempty"`
	Topic     string `json:"topic,omitempty"`
	Sender    string `json:"sender,omitempty"`
	Mentioned *bool  `json:"mentioned,omitempty"`
}

type DuckDuckGoConfig added in v0.1.2 

type DuckDuckGoConfig struct {
	Enabled    bool `json:"enabled"     env:"PICOCLAW_TOOLS_WEB_DUCKDUCKGO_ENABLED"`
	MaxResults int  `json:"max_results" env:"PICOCLAW_TOOLS_WEB_DUCKDUCKGO_MAX_RESULTS"`
}

type ExecConfig added in v0.2.0 

type ExecConfig struct {
	ToolConfig          `         envPrefix:"PICOCLAW_TOOLS_EXEC_"`
	EnableDenyPatterns  bool     `                                 json:"enable_deny_patterns"  env:"PICOCLAW_TOOLS_EXEC_ENABLE_DENY_PATTERNS"`
	AllowRemote         bool     `                                 json:"allow_remote"          env:"PICOCLAW_TOOLS_EXEC_ALLOW_REMOTE"`
	CustomDenyPatterns  []string `                                 json:"custom_deny_patterns"  env:"PICOCLAW_TOOLS_EXEC_CUSTOM_DENY_PATTERNS"`
	CustomAllowPatterns []string `                                 json:"custom_allow_patterns" env:"PICOCLAW_TOOLS_EXEC_CUSTOM_ALLOW_PATTERNS"`
	TimeoutSeconds      int      `                                 json:"timeout_seconds"       env:"PICOCLAW_TOOLS_EXEC_TIMEOUT_SECONDS"` // 0 means use default (60s)
}

type ExposePath added in v0.2.6 

type ExposePath struct {
	Source string `json:"source"`
	Target string `json:"target,omitempty"`
	Mode   string `json:"mode"`
}

ExposePath describes a host path that should remain visible inside the isolated child-process environment. This is currently implemented on Linux only.

type FeishuSettings added in v0.2.7 

type FeishuSettings struct {
	AppID               string              `json:"app_id"                      yaml:"-"                            env:"PICOCLAW_CHANNELS_FEISHU_APP_ID"`
	AppSecret           SecureString        `json:"app_secret,omitzero"         yaml:"app_secret,omitempty"         env:"PICOCLAW_CHANNELS_FEISHU_APP_SECRET"`
	EncryptKey          SecureString        `json:"encrypt_key,omitzero"        yaml:"encrypt_key,omitempty"        env:"PICOCLAW_CHANNELS_FEISHU_ENCRYPT_KEY"`
	VerificationToken   SecureString        `json:"verification_token,omitzero" yaml:"verification_token,omitempty" env:"PICOCLAW_CHANNELS_FEISHU_VERIFICATION_TOKEN"`
	RandomReactionEmoji FlexibleStringSlice `json:"random_reaction_emoji"       yaml:"-"                            env:"PICOCLAW_CHANNELS_FEISHU_RANDOM_REACTION_EMOJI"`
	IsLark              bool                `json:"is_lark"                     yaml:"-"                            env:"PICOCLAW_CHANNELS_FEISHU_IS_LARK"`
}

type FlexibleStringSlice added in v0.1.1 

type FlexibleStringSlice []string

FlexibleStringSlice is a []string that also accepts JSON numbers, so allow_from can contain both "123" and 123. It also supports parsing comma-separated strings from environment variables, including both English (,) and Chinese (，) commas.

func (*FlexibleStringSlice) UnmarshalJSON added in v0.1.1 

func (f *FlexibleStringSlice) UnmarshalJSON(data []byte) error

func (*FlexibleStringSlice) UnmarshalText added in v0.2.3 

func (f *FlexibleStringSlice) UnmarshalText(text []byte) error

UnmarshalText implements encoding.TextUnmarshaler to support env variable parsing. It handles comma-separated values with both English (,) and Chinese (，) commas.

type GLMSearchConfig added in v0.2.1 

type GLMSearchConfig struct {
	Enabled bool         `json:"enabled"          yaml:"-"                 env:"PICOCLAW_TOOLS_WEB_GLM_ENABLED"`
	APIKey  SecureString `json:"api_key,omitzero" yaml:"api_key,omitempty" env:"PICOCLAW_TOOLS_WEB_GLM_API_KEY"`
	BaseURL string       `json:"base_url"         yaml:"-"                 env:"PICOCLAW_TOOLS_WEB_GLM_BASE_URL"`
	// SearchEngine specifies the search backend: "search_std" (default),
	// "search_pro", "search_pro_sogou", or "search_pro_quark".
	SearchEngine string `json:"search_engine" yaml:"-" env:"PICOCLAW_TOOLS_WEB_GLM_SEARCH_ENGINE"`
	MaxResults   int    `json:"max_results"   yaml:"-" env:"PICOCLAW_TOOLS_WEB_GLM_MAX_RESULTS"`
}

type GatewayConfig 

type GatewayConfig struct {
	Host      string `json:"host"                env:"PICOCLAW_GATEWAY_HOST"`
	Port      int    `json:"port"                env:"PICOCLAW_GATEWAY_PORT"`
	HotReload bool   `json:"hot_reload"          env:"PICOCLAW_GATEWAY_HOT_RELOAD"`
	LogLevel  string `json:"log_level,omitempty" env:"PICOCLAW_LOG_LEVEL"`
}

type GroupTriggerConfig added in v0.2.0 

type GroupTriggerConfig struct {
	MentionOnly bool     `json:"mention_only,omitempty"`
	Prefixes    []string `json:"prefixes,omitempty"`
}

GroupTriggerConfig controls when the bot responds in group chats.

type HeartbeatConfig added in v0.1.2 

type HeartbeatConfig struct {
	Enabled  bool `json:"enabled"  env:"PICOCLAW_HEARTBEAT_ENABLED"`
	Interval int  `json:"interval" env:"PICOCLAW_HEARTBEAT_INTERVAL"` // minutes, min 5
}

type HookDefaultsConfig added in v0.2.4 

type HookDefaultsConfig struct {
	ObserverTimeoutMS    int `json:"observer_timeout_ms,omitempty"`
	InterceptorTimeoutMS int `json:"interceptor_timeout_ms,omitempty"`
	ApprovalTimeoutMS    int `json:"approval_timeout_ms,omitempty"`
}

type HooksConfig added in v0.2.4 

type HooksConfig struct {
	Enabled   bool                         `json:"enabled"`
	Defaults  HookDefaultsConfig           `json:"defaults,omitempty"`
	Builtins  map[string]BuiltinHookConfig `json:"builtins,omitempty"`
	Processes map[string]ProcessHookConfig `json:"processes,omitempty"`
}

type IRCSettings added in v0.2.7 

type IRCSettings struct {
	Server           string              `json:"server"                     yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_SERVER"`
	TLS              bool                `json:"tls"                        yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_TLS"`
	Nick             string              `json:"nick"                       yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_NICK"`
	User             string              `json:"user,omitempty"             yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_USER"`
	RealName         string              `json:"real_name,omitempty"        yaml:"-"`
	Password         SecureString        `json:"password,omitzero"          yaml:"password,omitempty"          env:"PICOCLAW_CHANNELS_IRC_PASSWORD"`
	NickServPassword SecureString        `json:"nickserv_password,omitzero" yaml:"nickserv_password,omitempty" env:"PICOCLAW_CHANNELS_IRC_NICKSERV_PASSWORD"`
	SASLUser         string              `json:"sasl_user"                  yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_SASL_USER"`
	SASLPassword     SecureString        `json:"sasl_password,omitzero"     yaml:"sasl_password,omitempty"     env:"PICOCLAW_CHANNELS_IRC_SASL_PASSWORD"`
	Channels         FlexibleStringSlice `json:"channels"                   yaml:"-"                           env:"PICOCLAW_CHANNELS_IRC_CHANNELS"`
	RequestCaps      FlexibleStringSlice `json:"request_caps,omitempty"     yaml:"-"`
}

type IsolationConfig added in v0.2.6 

type IsolationConfig struct {
	Enabled     bool         `json:"enabled,omitempty"`
	ExposePaths []ExposePath `json:"expose_paths,omitempty"`
}

IsolationConfig controls subprocess isolation for commands started by PicoClaw. It is applied by the isolation package rather than by sandboxing the main process.

type LINESettings added in v0.2.7 

type LINESettings struct {
	ChannelSecret      SecureString `json:"channel_secret,omitzero"       yaml:"channel_secret,omitempty"       env:"PICOCLAW_CHANNELS_LINE_CHANNEL_SECRET"`
	ChannelAccessToken SecureString `json:"channel_access_token,omitzero" yaml:"channel_access_token,omitempty" env:"PICOCLAW_CHANNELS_LINE_CHANNEL_ACCESS_TOKEN"`
	WebhookHost        string       `json:"webhook_host"                  yaml:"-"                              env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_HOST"`
	WebhookPort        int          `json:"webhook_port"                  yaml:"-"                              env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PORT"`
	WebhookPath        string       `json:"webhook_path"                  yaml:"-"                              env:"PICOCLAW_CHANNELS_LINE_WEBHOOK_PATH"`
}

type MCPConfig added in v0.2.1 

type MCPConfig struct {
	ToolConfig `                    envPrefix:"PICOCLAW_TOOLS_MCP_"`
	Discovery  ToolDiscoveryConfig `                                json:"discovery"`
	// MaxInlineTextChars controls how much MCP text stays inline before it is saved as an artifact.
	MaxInlineTextChars int `json:"max_inline_text_chars,omitempty" env:"PICOCLAW_TOOLS_MCP_MAX_INLINE_TEXT_CHARS"`
	// Servers is a map of server name to server configuration
	Servers map[string]MCPServerConfig `json:"servers,omitempty"`
}

MCPConfig defines configuration for all MCP servers

func (*MCPConfig) GetMaxInlineTextChars added in v0.2.6 

func (c *MCPConfig) GetMaxInlineTextChars() int

type MCPServerConfig added in v0.2.1 

type MCPServerConfig struct {
	// Enabled indicates whether this MCP server is active
	Enabled bool `json:"enabled"`
	// Deferred controls whether this server's tools are registered as hidden (deferred/discovery mode).
	// When nil, the global Discovery.Enabled setting applies.
	// When explicitly set to true or false, it overrides the global setting for this server only.
	Deferred *bool `json:"deferred,omitempty"`
	// Command is the executable to run (e.g., "npx", "python", "/path/to/server")
	Command string `json:"command"`
	// Args are the arguments to pass to the command
	Args []string `json:"args,omitempty"`
	// Env are environment variables to set for the server process (stdio only)
	Env map[string]string `json:"env,omitempty"`
	// EnvFile is the path to a file containing environment variables (stdio only)
	EnvFile string `json:"env_file,omitempty"`
	// Type is "stdio", "sse", or "http" (default: stdio if command is set, sse if url is set)
	Type string `json:"type,omitempty"`
	// URL is used for SSE/HTTP transport
	URL string `json:"url,omitempty"`
	// Headers are HTTP headers to send with requests (sse/http only)
	Headers map[string]string `json:"headers,omitempty"`
}

MCPServerConfig defines configuration for a single MCP server

type MaixCamSettings added in v0.2.7 

type MaixCamSettings struct {
	Host string `json:"host" yaml:"-" env:"PICOCLAW_CHANNELS_MAIXCAM_HOST"`
	Port int    `json:"port" yaml:"-" env:"PICOCLAW_CHANNELS_MAIXCAM_PORT"`
}

type MatrixSettings added in v0.2.7 

type MatrixSettings struct {
	Homeserver         string       `json:"homeserver"                     yaml:"-"                      env:"PICOCLAW_CHANNELS_MATRIX_HOMESERVER"`
	UserID             string       `json:"user_id"                        yaml:"-"                      env:"PICOCLAW_CHANNELS_MATRIX_USER_ID"`
	AccessToken        SecureString `json:"access_token,omitzero"          yaml:"access_token,omitempty" env:"PICOCLAW_CHANNELS_MATRIX_ACCESS_TOKEN"`
	DeviceID           string       `json:"device_id,omitempty"            yaml:"-"`
	JoinOnInvite       bool         `json:"join_on_invite"                 yaml:"-"`
	MessageFormat      string       `json:"message_format,omitempty"       yaml:"-"`
	CryptoDatabasePath string       `json:"crypto_database_path,omitempty" yaml:"-"`
	CryptoPassphrase   string       `json:"crypto_passphrase,omitempty"    yaml:"-"`
}

type MediaCleanupConfig added in v0.2.0 

type MediaCleanupConfig struct {
	ToolConfig `    envPrefix:"PICOCLAW_MEDIA_CLEANUP_"`
	MaxAge     int `                                    json:"max_age_minutes"  env:"PICOCLAW_MEDIA_CLEANUP_MAX_AGE"`
	Interval   int `                                    json:"interval_minutes" env:"PICOCLAW_MEDIA_CLEANUP_INTERVAL"`
}

type ModelConfig added in v0.2.0 

type ModelConfig struct {
	// Required fields
	ModelName string `json:"model_name"` // User-facing alias for the model
	Model     string `json:"model"`      // Protocol/model-identifier (e.g., "openai/gpt-4o", "anthropic/claude-sonnet-4.6")

	// HTTP-based providers
	APIBase   string   `json:"api_base,omitempty"`  // API endpoint URL
	Proxy     string   `json:"proxy,omitempty"`     // HTTP proxy URL
	Fallbacks []string `json:"fallbacks,omitempty"` // Fallback model names for failover

	// Special providers (CLI-based, OAuth, etc.)
	AuthMethod  string `json:"auth_method,omitempty"`  // Authentication method: oauth, token
	ConnectMode string `json:"connect_mode,omitempty"` // Connection mode: stdio, grpc
	Workspace   string `json:"workspace,omitempty"`    // Workspace path for CLI-based providers

	// Optional optimizations
	RPM            int               `json:"rpm,omitempty"`              // Requests per minute limit
	MaxTokensField string            `json:"max_tokens_field,omitempty"` // Field name for max tokens (e.g., "max_completion_tokens")
	RequestTimeout int               `json:"request_timeout,omitempty"`
	ThinkingLevel  string            `json:"thinking_level,omitempty"` // Extended thinking: off|low|medium|high|xhigh|adaptive
	ExtraBody      map[string]any    `json:"extra_body,omitempty"`     // Additional fields to inject into request body
	CustomHeaders  map[string]string `json:"custom_headers,omitempty"` // Additional headers to inject into every HTTP request

	APIKeys SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty"` // API authentication keys (multiple keys for failover)

	// Enabled indicates whether this model entry is active. When omitted in
	// existing configs, the field is inferred during load: models with API keys
	// or the reserved "local-model" name are auto-enabled.
	Enabled bool `json:"enabled,omitempty" yaml:"enabled,omitempty"`
	// UserAgent is the user agent string to use for HTTP requests.
	UserAgent string `json:"user_agent,omitempty" yaml:"-"`
	// contains filtered or unexported fields
}

ModelConfig represents a model-centric provider configuration. It allows adding new providers (especially OpenAI-compatible ones) via configuration only. The model field uses protocol prefix format: [protocol/]model-identifier Supported protocols include openai, anthropic, antigravity, claude-cli, codex-cli, github-copilot, and named OpenAI-compatible protocols such as groq, deepseek, modelscope, and novita. Default protocol is "openai" if no prefix is specified.

func (*ModelConfig) APIKey added in v0.2.0 

func (c *ModelConfig) APIKey() string

APIKey returns the first API key from apiKeys

func (*ModelConfig) IsVirtual added in v0.2.4 

func (c *ModelConfig) IsVirtual() bool

IsVirtual returns true if this model was generated from multi-key expansion.

func (*ModelConfig) SetAPIKey added in v0.2.4 

func (c *ModelConfig) SetAPIKey(value string)

func (*ModelConfig) Validate added in v0.2.0 

func (c *ModelConfig) Validate() error

Validate checks if the ModelConfig has all required fields.

type OneBotSettings added in v0.2.7 

type OneBotSettings struct {
	WSUrl              string       `json:"ws_url"                yaml:"-"                      env:"PICOCLAW_CHANNELS_ONEBOT_WS_URL"`
	AccessToken        SecureString `json:"access_token,omitzero" yaml:"access_token,omitempty" env:"PICOCLAW_CHANNELS_ONEBOT_ACCESS_TOKEN"`
	ReconnectInterval  int          `json:"reconnect_interval"    yaml:"-"                      env:"PICOCLAW_CHANNELS_ONEBOT_RECONNECT_INTERVAL"`
	GroupTriggerPrefix []string     `json:"group_trigger_prefix"  yaml:"-"                      env:"PICOCLAW_CHANNELS_ONEBOT_GROUP_TRIGGER_PREFIX"`
}

type PerplexityConfig added in v0.2.0 

type PerplexityConfig struct {
	Enabled    bool          `json:"enabled"           yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_ENABLED"`
	APIKeys    SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty" env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_API_KEYS"`
	MaxResults int           `json:"max_results"       yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_PERPLEXITY_MAX_RESULTS"`
}

func (*PerplexityConfig) APIKey added in v0.2.0 

func (c *PerplexityConfig) APIKey() string

APIKey returns the Perplexity API key

func (*PerplexityConfig) SetAPIKey added in v0.2.4 

func (c *PerplexityConfig) SetAPIKey(key string)

SetAPIKey sets the Perplexity API key

type PicoClientSettings added in v0.2.7 

type PicoClientSettings struct {
	URL          string       `json:"url"                     yaml:"-"               env:"PICOCLAW_CHANNELS_PICO_CLIENT_URL"`
	Token        SecureString `json:"token,omitzero"          yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_PICO_CLIENT_TOKEN"`
	SessionID    string       `json:"session_id,omitempty"    yaml:"-"`
	PingInterval int          `json:"ping_interval,omitempty" yaml:"-"`
	ReadTimeout  int          `json:"read_timeout,omitempty"  yaml:"-"`
}

type PicoSettings added in v0.2.7 

type PicoSettings struct {
	Token           SecureString `json:"token,omitzero"              yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_PICO_TOKEN"`
	AllowTokenQuery bool         `json:"allow_token_query,omitempty" yaml:"-"`
	AllowOrigins    []string     `json:"allow_origins,omitempty"     yaml:"-"`
	PingInterval    int          `json:"ping_interval,omitempty"     yaml:"-"`
	ReadTimeout     int          `json:"read_timeout,omitempty"      yaml:"-"`
	WriteTimeout    int          `json:"write_timeout,omitempty"     yaml:"-"`
	MaxConnections  int          `json:"max_connections,omitempty"   yaml:"-"`
}

func (*PicoSettings) SetToken added in v0.2.7 

func (c *PicoSettings) SetToken(token string)

SetToken sets the Pico token and marks it as dirty for security saving

type PlaceholderConfig added in v0.2.0 

type PlaceholderConfig struct {
	Enabled bool                `json:"enabled"`
	Text    FlexibleStringSlice `json:"text,omitempty"`
}

PlaceholderConfig controls placeholder message behavior (Phase 10).

func (*PlaceholderConfig) GetRandomText added in v0.2.5 

func (p *PlaceholderConfig) GetRandomText() string

GetRandomText returns a random placeholder text, or default if none set.

type ProcessHookConfig added in v0.2.4 

type ProcessHookConfig struct {
	Enabled   bool              `json:"enabled"`
	Priority  int               `json:"priority,omitempty"`
	Transport string            `json:"transport,omitempty"`
	Command   []string          `json:"command,omitempty"`
	Dir       string            `json:"dir,omitempty"`
	Env       map[string]string `json:"env,omitempty"`
	Observe   []string          `json:"observe,omitempty"`
	Intercept []string          `json:"intercept,omitempty"`
}

type QQSettings added in v0.2.7 

type QQSettings struct {
	AppID                string       `json:"app_id"                   yaml:"-"                    env:"PICOCLAW_CHANNELS_QQ_APP_ID"`
	AppSecret            SecureString `json:"app_secret,omitzero"      yaml:"app_secret,omitempty" env:"PICOCLAW_CHANNELS_QQ_APP_SECRET"`
	MaxMessageLength     int          `json:"max_message_length"       yaml:"-"                    env:"PICOCLAW_CHANNELS_QQ_MAX_MESSAGE_LENGTH"`
	MaxBase64FileSizeMiB int64        `json:"max_base64_file_size_mib" yaml:"-"                    env:"PICOCLAW_CHANNELS_QQ_MAX_BASE64_FILE_SIZE_MIB"`
	SendMarkdown         bool         `json:"send_markdown"            yaml:"-"                    env:"PICOCLAW_CHANNELS_QQ_SEND_MARKDOWN"`
}

type RawNode added in v0.2.7 

type RawNode json.RawMessage

RawNode stores raw configuration data as JSON bytes, supporting both JSON and YAML. Internally uses json.RawMessage, so Decode always uses json.Unmarshal which correctly respects json struct tags.

func (*RawNode) Decode added in v0.2.7 

func (r *RawNode) Decode(target any) error

Decode unmarshals the stored data into the given target struct using json.Unmarshal.

func (*RawNode) IsEmpty added in v0.2.7 

func (r *RawNode) IsEmpty() bool

IsEmpty returns true if the node has not been populated.

func (RawNode) MarshalJSON added in v0.2.7 

func (r RawNode) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler: outputs stored JSON bytes.

func (RawNode) MarshalYAML added in v0.2.7 

func (r RawNode) MarshalYAML() (any, error)

MarshalYAML implements yaml.ValueMarshaler: converts stored JSON back to a YAML-compatible value.

func (*RawNode) UnmarshalJSON added in v0.2.7 

func (r *RawNode) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler: stores raw JSON bytes. NOTE: yaml.Unmarshal may call this when unmarshaling into RawNode fields. We detect if the input looks like YAML (not JSON) and handle it.

func (*RawNode) UnmarshalYAML added in v0.2.7 

func (r *RawNode) UnmarshalYAML(value *yaml.Node) error

UnmarshalYAML implements yaml.Unmarshaler: converts YAML node to JSON bytes. Merges the incoming YAML values with existing data, with YAML taking precedence.

type ReadFileToolConfig added in v0.2.2 

type ReadFileToolConfig struct {
	Enabled         bool   `json:"enabled"`
	Mode            string `json:"mode"`
	MaxReadFileSize int    `json:"max_read_file_size"`
}

func (ReadFileToolConfig) EffectiveMode added in v0.2.5 

func (c ReadFileToolConfig) EffectiveMode() string

type RoutingConfig added in v0.2.1 

type RoutingConfig struct {
	Enabled    bool    `json:"enabled"`
	LightModel string  `json:"light_model"` // model_name from model_list to use for simple tasks
	Threshold  float64 `json:"threshold"`   // complexity score in [0,1]; score >= threshold → primary model
}

RoutingConfig controls the intelligent model routing feature. When enabled, each incoming message is scored against structural features (message length, code blocks, tool call history, conversation depth, attachments). Messages scoring below Threshold are sent to LightModel; all others use the agent's primary model. This reduces cost and latency for simple tasks without requiring any keyword matching — all scoring is language-agnostic.

type SearXNGConfig added in v0.2.1 

type SearXNGConfig struct {
	Enabled    bool   `json:"enabled"     env:"PICOCLAW_TOOLS_WEB_SEARXNG_ENABLED"`
	BaseURL    string `json:"base_url"    env:"PICOCLAW_TOOLS_WEB_SEARXNG_BASE_URL"`
	MaxResults int    `json:"max_results" env:"PICOCLAW_TOOLS_WEB_SEARXNG_MAX_RESULTS"`
}

type SearchCacheConfig added in v0.2.0 

type SearchCacheConfig struct {
	MaxSize    int `json:"max_size"    env:"PICOCLAW_SKILLS_SEARCH_CACHE_MAX_SIZE"`
	TTLSeconds int `json:"ttl_seconds" env:"PICOCLAW_SKILLS_SEARCH_CACHE_TTL_SECONDS"`
}

type SecureModelList added in v0.2.5 

type SecureModelList []*ModelConfig

func (SecureModelList) MarshalYAML added in v0.2.5 

func (v SecureModelList) MarshalYAML() (any, error)

func (*SecureModelList) UnmarshalYAML added in v0.2.5 

func (v *SecureModelList) UnmarshalYAML(value *yaml.Node) error

type SecureString added in v0.2.5 

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

SecureString the string value that can be decrypted or resolved

func NewSecureString added in v0.2.5 

func NewSecureString(value string) *SecureString

func (SecureString) IsZero added in v0.2.5 

func (s SecureString) IsZero() bool

IsZero returns true if the SecureString is empty if caller not yaml, just return true for prevent marshal this field

func (SecureString) MarshalJSON added in v0.2.5 

func (s SecureString) MarshalJSON() ([]byte, error)

func (SecureString) MarshalYAML added in v0.2.5 

func (s SecureString) MarshalYAML() (any, error)

func (*SecureString) Set added in v0.2.5 

func (s *SecureString) Set(value string) *SecureString

func (*SecureString) String added in v0.2.5 

func (s *SecureString) String() string

func (*SecureString) UnmarshalJSON added in v0.2.5 

func (s *SecureString) UnmarshalJSON(value []byte) error

func (*SecureString) UnmarshalText added in v0.2.5 

func (s *SecureString) UnmarshalText(text []byte) error

func (*SecureString) UnmarshalYAML added in v0.2.5 

func (s *SecureString) UnmarshalYAML(value *yaml.Node) error

type SecureStrings added in v0.2.5 

type SecureStrings []*SecureString

SecureStrings is a slice of SecureString

func SimpleSecureStrings added in v0.2.5 

func SimpleSecureStrings(val ...string) SecureStrings

func (SecureStrings) IsZero added in v0.2.7 

func (s SecureStrings) IsZero() bool

IsZero returns true if the SecureStrings is nil or empty.

func (SecureStrings) MarshalJSON added in v0.2.5 

func (s SecureStrings) MarshalJSON() ([]byte, error)

func (*SecureStrings) UnmarshalJSON added in v0.2.5 

func (s *SecureStrings) UnmarshalJSON(value []byte) error

func (*SecureStrings) Values added in v0.2.5 

func (s *SecureStrings) Values() []string

Values returns the decrypted/resolved values

type SensitiveDataCache added in v0.2.4 

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

SensitiveDataCache caches the strings.Replacer for filtering sensitive data. Computed once on first access via sync.Once.

type SessionConfig added in v0.2.0 

type SessionConfig struct {
	Dimensions    []string            `json:"dimensions,omitempty"`
	IdentityLinks map[string][]string `json:"identity_links,omitempty"`
}

type SkillRegistryConfig added in v0.2.7 

type SkillRegistryConfig struct {
	Name      string         `json:"name,omitempty"      yaml:"-"                    env:"-"`
	Enabled   bool           `json:"enabled"             yaml:"-"                    env:"-"`
	BaseURL   string         `json:"base_url"            yaml:"-"                    env:"-"`
	AuthToken SecureString   `json:"auth_token,omitzero" yaml:"auth_token,omitempty" env:"-"`
	Param     map[string]any `json:"-"                   yaml:"-"                    env:"-"`
}

func (*SkillRegistryConfig) DecodeParam added in v0.2.7 

func (c *SkillRegistryConfig) DecodeParam(target any) error

func (SkillRegistryConfig) MarshalJSON added in v0.2.7 

func (c SkillRegistryConfig) MarshalJSON() ([]byte, error)

func (SkillRegistryConfig) MarshalYAML added in v0.2.7 

func (c SkillRegistryConfig) MarshalYAML() (any, error)

func (*SkillRegistryConfig) UnmarshalJSON added in v0.2.7 

func (c *SkillRegistryConfig) UnmarshalJSON(data []byte) error

func (*SkillRegistryConfig) UnmarshalYAML added in v0.2.7 

func (c *SkillRegistryConfig) UnmarshalYAML(value *yaml.Node) error

type SkillsGithubConfig added in v0.2.3 

type SkillsGithubConfig struct {
	BaseURL string       `json:"base_url,omitempty" yaml:"-"               env:"PICOCLAW_TOOLS_SKILLS_GITHUB_BASE_URL"`
	Token   SecureString `json:"token,omitzero"     yaml:"token,omitempty" env:"PICOCLAW_TOOLS_SKILLS_GITHUB_TOKEN"`
	Proxy   string       `json:"proxy,omitempty"    yaml:"-"               env:"PICOCLAW_TOOLS_SKILLS_GITHUB_PROXY"`
}

type SkillsRegistriesConfig added in v0.2.0 

type SkillsRegistriesConfig []*SkillRegistryConfig

func (*SkillsRegistriesConfig) Get added in v0.2.7 

func (c *SkillsRegistriesConfig) Get(name string) (SkillRegistryConfig, bool)

func (SkillsRegistriesConfig) MarshalJSON added in v0.2.7 

func (v SkillsRegistriesConfig) MarshalJSON() ([]byte, error)

func (SkillsRegistriesConfig) MarshalYAML added in v0.2.7 

func (v SkillsRegistriesConfig) MarshalYAML() (any, error)

func (*SkillsRegistriesConfig) Set added in v0.2.7 

func (c *SkillsRegistriesConfig) Set(name string, cfg SkillRegistryConfig)

func (*SkillsRegistriesConfig) UnmarshalJSON added in v0.2.7 

func (v *SkillsRegistriesConfig) UnmarshalJSON(data []byte) error

func (*SkillsRegistriesConfig) UnmarshalYAML added in v0.2.7 

func (v *SkillsRegistriesConfig) UnmarshalYAML(value *yaml.Node) error

type SkillsToolsConfig added in v0.2.0 

type SkillsToolsConfig struct {
	ToolConfig `                       yaml:"-"                    envPrefix:"PICOCLAW_TOOLS_SKILLS_"`
	Registries SkillsRegistriesConfig `yaml:"registries,omitempty"                                    json:"registries"`
	// Deprecated: use registries.github instead.
	Github                SkillsGithubConfig `yaml:"github,omitempty" json:"github"`
	MaxConcurrentSearches int                `yaml:"-"                json:"max_concurrent_searches" env:"PICOCLAW_TOOLS_SKILLS_MAX_CONCURRENT_SEARCHES"`
	SearchCache           SearchCacheConfig  `yaml:"-"                json:"search_cache"`
}

type SlackSettings added in v0.2.7 

type SlackSettings struct {
	BotToken SecureString `json:"bot_token,omitzero" yaml:"bot_token,omitempty" env:"PICOCLAW_CHANNELS_SLACK_BOT_TOKEN"`
	AppToken SecureString `json:"app_token,omitzero" yaml:"app_token,omitempty" env:"PICOCLAW_CHANNELS_SLACK_APP_TOKEN"`
}

type SogouConfig added in v0.2.7 

type SogouConfig struct {
	Enabled    bool `json:"enabled"     env:"PICOCLAW_TOOLS_WEB_SOGOU_ENABLED"`
	MaxResults int  `json:"max_results" env:"PICOCLAW_TOOLS_WEB_SOGOU_MAX_RESULTS"`
}

type StreamingConfig added in v0.2.4 

type StreamingConfig struct {
	Enabled         bool `json:"enabled,omitempty"          env:"PICOCLAW_CHANNELS_TELEGRAM_STREAMING_ENABLED"`
	ThrottleSeconds int  `json:"throttle_seconds,omitempty" env:"PICOCLAW_CHANNELS_TELEGRAM_STREAMING_THROTTLE_SECONDS"`
	MinGrowthChars  int  `json:"min_growth_chars,omitempty" env:"PICOCLAW_CHANNELS_TELEGRAM_STREAMING_MIN_GROWTH_CHARS"`
}

type SubTurnConfig added in v0.2.4 

type SubTurnConfig struct {
	MaxDepth              int `json:"max_depth"               env:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_MAX_DEPTH"`
	MaxConcurrent         int `json:"max_concurrent"          env:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_MAX_CONCURRENT"`
	DefaultTimeoutMinutes int `json:"default_timeout_minutes" env:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_DEFAULT_TIMEOUT_MINUTES"`
	DefaultTokenBudget    int `json:"default_token_budget"    env:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_DEFAULT_TOKEN_BUDGET"`
	ConcurrencyTimeoutSec int `json:"concurrency_timeout_sec" env:"PICOCLAW_AGENTS_DEFAULTS_SUBTURN_CONCURRENCY_TIMEOUT_SEC"`
}

SubTurnConfig configures the SubTurn execution system.

type SubagentsConfig added in v0.2.0 

type SubagentsConfig struct {
	AllowAgents []string          `json:"allow_agents,omitempty"`
	Model       *AgentModelConfig `json:"model,omitempty"`
}

type TavilyConfig added in v0.2.0 

type TavilyConfig struct {
	Enabled    bool          `json:"enabled"           yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_TAVILY_ENABLED"`
	APIKeys    SecureStrings `json:"api_keys,omitzero" yaml:"api_keys,omitempty" env:"PICOCLAW_TOOLS_WEB_TAVILY_API_KEYS"`
	BaseURL    string        `json:"base_url"          yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_TAVILY_BASE_URL"`
	MaxResults int           `json:"max_results"       yaml:"-"                  env:"PICOCLAW_TOOLS_WEB_TAVILY_MAX_RESULTS"`
}

func (*TavilyConfig) APIKey added in v0.2.0 

func (c *TavilyConfig) APIKey() string

APIKey returns the Tavily API key

func (*TavilyConfig) SetAPIKey added in v0.2.4 

func (c *TavilyConfig) SetAPIKey(key string)

SetAPIKey sets the Tavily API key

func (*TavilyConfig) SetAPIKeys added in v0.2.4 

func (c *TavilyConfig) SetAPIKeys(keys []string)

SetAPIKeys sets the Tavily API keys

type TeamsWebhookSettings added in v0.2.7 

type TeamsWebhookSettings struct {
	Webhooks map[string]TeamsWebhookTarget `json:"webhooks" yaml:"webhooks,omitempty"`
}

TeamsWebhookSettings configures the output-only Microsoft Teams webhook channel. Multiple webhook targets can be configured and selected via ChatID at send time.

type TeamsWebhookTarget added in v0.2.6 

type TeamsWebhookTarget struct {
	WebhookURL SecureString `json:"webhook_url,omitzero" yaml:"webhook_url,omitempty"`
	Title      string       `json:"title,omitempty"      yaml:"-"`
}

TeamsWebhookTarget represents a single Teams webhook destination.

type TelegramSettings added in v0.2.7 

type TelegramSettings struct {
	Token         SecureString    `json:"token,omitzero"      yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_TELEGRAM_TOKEN"`
	BaseURL       string          `json:"base_url"            yaml:"-"               env:"PICOCLAW_CHANNELS_TELEGRAM_BASE_URL"`
	Proxy         string          `json:"proxy"               yaml:"-"               env:"PICOCLAW_CHANNELS_TELEGRAM_PROXY"`
	Streaming     StreamingConfig `json:"streaming,omitempty" yaml:"-"`
	UseMarkdownV2 bool            `json:"use_markdown_v2"     yaml:"-"               env:"PICOCLAW_CHANNELS_TELEGRAM_USE_MARKDOWN_V2"`
}

type ToolConfig added in v0.2.1 

type ToolConfig struct {
	Enabled bool `json:"enabled" yaml:"-" env:"ENABLED"`
}

type ToolDiscoveryConfig added in v0.2.2 

type ToolDiscoveryConfig struct {
	Enabled          bool `json:"enabled"            env:"PICOCLAW_TOOLS_DISCOVERY_ENABLED"`
	TTL              int  `json:"ttl"                env:"PICOCLAW_TOOLS_DISCOVERY_TTL"`
	MaxSearchResults int  `json:"max_search_results" env:"PICOCLAW_MAX_SEARCH_RESULTS"`
	UseBM25          bool `json:"use_bm25"           env:"PICOCLAW_TOOLS_DISCOVERY_USE_BM25"`
	UseRegex         bool `json:"use_regex"          env:"PICOCLAW_TOOLS_DISCOVERY_USE_REGEX"`
}

type ToolFeedbackConfig added in v0.2.4 

type ToolFeedbackConfig struct {
	Enabled       bool `json:"enabled"         env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_ENABLED"`
	MaxArgsLength int  `json:"max_args_length" env:"PICOCLAW_AGENTS_DEFAULTS_TOOL_FEEDBACK_MAX_ARGS_LENGTH"`
}

type ToolsConfig 

type ToolsConfig struct {
	AllowReadPaths  []string `json:"allow_read_paths"  yaml:"-" env:"PICOCLAW_TOOLS_ALLOW_READ_PATHS"`
	AllowWritePaths []string `json:"allow_write_paths" yaml:"-" env:"PICOCLAW_TOOLS_ALLOW_WRITE_PATHS"`
	// FilterSensitiveData controls whether to filter sensitive values (API keys,
	// tokens, secrets) from tool results before sending to the LLM.
	// Default: true (enabled)
	FilterSensitiveData bool `json:"filter_sensitive_data" yaml:"-" env:"PICOCLAW_TOOLS_FILTER_SENSITIVE_DATA"`
	// FilterMinLength is the minimum content length required for filtering.
	// Content shorter than this will be returned unchanged for performance.
	// Default: 8
	FilterMinLength int                `json:"filter_min_length" yaml:"-"                env:"PICOCLAW_TOOLS_FILTER_MIN_LENGTH"`
	Web             WebToolsConfig     `json:"web"               yaml:"web,omitempty"`
	Cron            CronToolsConfig    `json:"cron"              yaml:"-"`
	Exec            ExecConfig         `json:"exec"              yaml:"-"`
	Skills          SkillsToolsConfig  `json:"skills"            yaml:"skills,omitempty"`
	MediaCleanup    MediaCleanupConfig `json:"media_cleanup"     yaml:"-"`
	MCP             MCPConfig          `json:"mcp"               yaml:"-"`
	AppendFile      ToolConfig         `` /* 127-byte string literal not displayed */
	EditFile        ToolConfig         `json:"edit_file"         yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_EDIT_FILE_"`
	FindSkills      ToolConfig         `` /* 127-byte string literal not displayed */
	I2C             ToolConfig         `json:"i2c"               yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_I2C_"`
	InstallSkill    ToolConfig         `` /* 129-byte string literal not displayed */
	ListDir         ToolConfig         `json:"list_dir"          yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_LIST_DIR_"`
	Message         ToolConfig         `json:"message"           yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_MESSAGE_"`
	ReadFile        ReadFileToolConfig `json:"read_file"         yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_READ_FILE_"`
	SendFile        ToolConfig         `json:"send_file"         yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_SEND_FILE_"`
	SendTTS         ToolConfig         `json:"send_tts"          yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_SEND_TTS_"`
	Spawn           ToolConfig         `json:"spawn"             yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_SPAWN_"`
	SpawnStatus     ToolConfig         `` /* 128-byte string literal not displayed */
	SPI             ToolConfig         `json:"spi"               yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_SPI_"`
	Subagent        ToolConfig         `json:"subagent"          yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_SUBAGENT_"`
	WebFetch        ToolConfig         `json:"web_fetch"         yaml:"-"                                                       envPrefix:"PICOCLAW_TOOLS_WEB_FETCH_"`
	WriteFile       ToolConfig         `` /* 126-byte string literal not displayed */
}

func (*ToolsConfig) GetFilterMinLength added in v0.2.4 

func (c *ToolsConfig) GetFilterMinLength() int

GetFilterMinLength returns the minimum content length for filtering (default: 8)

func (*ToolsConfig) IsFilterSensitiveDataEnabled added in v0.2.4 

func (c *ToolsConfig) IsFilterSensitiveDataEnabled() bool

IsFilterSensitiveDataEnabled returns true if sensitive data filtering is enabled

func (*ToolsConfig) IsToolEnabled added in v0.2.1 

func (t *ToolsConfig) IsToolEnabled(name string) bool

type TypingConfig added in v0.2.0 

type TypingConfig struct {
	Enabled bool `json:"enabled,omitempty"`
}

TypingConfig controls typing indicator behavior (Phase 10).

type VKSettings added in v0.2.7 

type VKSettings struct {
	Token   SecureString `json:"token,omitzero" yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_VK_TOKEN"`
	GroupID int          `json:"group_id"       yaml:"-"               env:"PICOCLAW_CHANNELS_VK_GROUP_ID"`
}

func (*VKSettings) SetToken added in v0.2.7 

func (c *VKSettings) SetToken(token string)

type VoiceConfig added in v0.2.2 

type VoiceConfig struct {
	ModelName         string `json:"model_name,omitempty"         env:"PICOCLAW_VOICE_MODEL_NAME"`
	TTSModelName      string `json:"tts_model_name,omitempty"     env:"PICOCLAW_VOICE_TTS_MODEL_NAME"`
	EchoTranscription bool   `json:"echo_transcription"           env:"PICOCLAW_VOICE_ECHO_TRANSCRIPTION"`
	ElevenLabsAPIKey  string `json:"elevenlabs_api_key,omitempty" env:"PICOCLAW_VOICE_ELEVENLABS_API_KEY"`
}

type WeComGroupConfig added in v0.2.4 

type WeComGroupConfig struct {
	AllowFrom FlexibleStringSlice `json:"allow_from,omitempty"`
}

type WeComSettings added in v0.2.7 

type WeComSettings struct {
	BotID               string       `json:"bot_id"                  yaml:"-"                env:"BOT_ID"`
	Secret              SecureString `json:"secret,omitzero"         yaml:"secret,omitempty" env:"SECRET"`
	WebSocketURL        string       `json:"websocket_url,omitempty" yaml:"-"                env:"WEBSOCKET_URL"`
	SendThinkingMessage bool         `json:"send_thinking_message"   yaml:"-"                env:"SEND_THINKING_MESSAGE"`
}

func (*WeComSettings) SetSecret added in v0.2.7 

func (c *WeComSettings) SetSecret(secret string)

type WebToolsConfig 

type WebToolsConfig struct {
	ToolConfig  `                  yaml:"-"                      envPrefix:"PICOCLAW_TOOLS_WEB_"`
	Brave       BraveConfig       `yaml:"brave,omitempty"                                        json:"brave"`
	Tavily      TavilyConfig      `yaml:"tavily,omitempty"                                       json:"tavily"`
	Sogou       SogouConfig       `yaml:"-"                                                      json:"sogou"`
	DuckDuckGo  DuckDuckGoConfig  `yaml:"-"                                                      json:"duckduckgo"`
	Perplexity  PerplexityConfig  `yaml:"perplexity,omitempty"                                   json:"perplexity"`
	SearXNG     SearXNGConfig     `yaml:"-"                                                      json:"searxng"`
	GLMSearch   GLMSearchConfig   `yaml:"glm_search,omitempty"                                   json:"glm_search"`
	BaiduSearch BaiduSearchConfig `yaml:"baidu_search,omitempty"                                 json:"baidu_search"`
	Provider    string            `yaml:"-"                                                      json:"provider,omitempty" env:"PICOCLAW_TOOLS_WEB_PROVIDER"`
	// PreferNative controls whether to use provider-native web search when
	// the active LLM supports it (e.g. OpenAI web_search_preview). When true,
	// the client-side web_search tool is hidden to avoid duplicate search surfaces,
	// and the provider's built-in search is used instead. Falls back to client-side
	// search when the provider does not support native search.
	PreferNative bool `yaml:"-" json:"prefer_native" env:"PICOCLAW_TOOLS_WEB_PREFER_NATIVE"`
	// Proxy is an optional proxy URL for web tools (http/https/socks5/socks5h).
	// For authenticated proxies, prefer HTTP_PROXY/HTTPS_PROXY env vars instead of embedding credentials in config.
	Proxy                string              `yaml:"-" json:"proxy,omitempty"                  env:"PICOCLAW_TOOLS_WEB_PROXY"`
	FetchLimitBytes      int64               `yaml:"-" json:"fetch_limit_bytes,omitempty"      env:"PICOCLAW_TOOLS_WEB_FETCH_LIMIT_BYTES"`
	Format               string              `yaml:"-" json:"format,omitempty"                 env:"PICOCLAW_TOOLS_WEB_FORMAT"`
	PrivateHostWhitelist FlexibleStringSlice `yaml:"-" json:"private_host_whitelist,omitempty" env:"PICOCLAW_TOOLS_WEB_PRIVATE_HOST_WHITELIST"`
}

type WeixinSettings added in v0.2.7 

type WeixinSettings struct {
	Token      SecureString `json:"token,omitzero"       yaml:"token,omitempty" env:"PICOCLAW_CHANNELS_WEIXIN_TOKEN"`
	AccountID  string       `json:"account_id,omitempty" yaml:"-"               env:"PICOCLAW_CHANNELS_WEIXIN_ACCOUNT_ID"`
	BaseURL    string       `json:"base_url"             yaml:"-"               env:"PICOCLAW_CHANNELS_WEIXIN_BASE_URL"`
	CDNBaseURL string       `json:"cdn_base_url"         yaml:"-"               env:"PICOCLAW_CHANNELS_WEIXIN_CDN_BASE_URL"`
	Proxy      string       `json:"proxy"                yaml:"-"               env:"PICOCLAW_CHANNELS_WEIXIN_PROXY"`
}

func (*WeixinSettings) SetToken added in v0.2.7 

func (c *WeixinSettings) SetToken(token string)

SetToken sets the Weixin token and marks it as dirty for security saving

type WhatsAppSettings added in v0.2.7 

type WhatsAppSettings struct {
	BridgeURL        string `json:"bridge_url"         yaml:"-" env:"PICOCLAW_CHANNELS_WHATSAPP_BRIDGE_URL"`
	UseNative        bool   `json:"use_native"         yaml:"-" env:"PICOCLAW_CHANNELS_WHATSAPP_USE_NATIVE"`
	SessionStorePath string `json:"session_store_path" yaml:"-" env:"PICOCLAW_CHANNELS_WHATSAPP_SESSION_STORE_PATH"`
}

Source Files

View all Source files

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.