agent

type Action struct {
	Type string                 `json:"type"` // "record", "search", "feedback", "outcome"
	Args map[string]interface{} `json:"args"`
}

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

type AssertResult struct {
	Assertion Assertion   `json:"assertion"`
	Passed    bool        `json:"passed"`
	Actual    interface{} `json:"actual,omitempty"`
	Message   string      `json:"message,omitempty"`
}

type Assertion struct {
	// Type of assertion
	// Options: "confidence_increased", "confidence_decreased",
	//          "confidence_above", "confidence_below",
	//          "memory_count", "weight_shifted"
	Type string `json:"type"`

	// Target identifies what to check (e.g., memory_id)
	Target string `json:"target,omitempty"`

	// Value for comparison
	Value interface{} `json:"value,omitempty"`

	// Message to show on failure
	Message string `json:"message,omitempty"`
}

type Config struct {
	Client    ContextdClient
	LLM       LLMClient
	Persona   Persona
	ProjectID string
	Logger    *zap.Logger
}

type ContentBlock struct {
	Type    string          `json:"type"`
	Text    string          `json:"text,omitempty"`
	ToolUse *ToolUseBlock   `json:"tool_use,omitempty"`
	ID      string          `json:"id,omitempty"`
	Name    string          `json:"name,omitempty"`
	Input   json.RawMessage `json:"input,omitempty"`
}

type ContextdClient interface {
	// Memory operations
	MemoryRecord(ctx context.Context, projectID, title, content, outcome string, tags []string) (string, float64, error)
	MemorySearch(ctx context.Context, projectID, query string, limit int) ([]MemoryResult, error)
	MemoryFeedback(ctx context.Context, memoryID string, helpful bool) (float64, error)
	MemoryOutcome(ctx context.Context, memoryID string, succeeded bool, sessionID string) (float64, error)

	// For observing state
	GetMemory(ctx context.Context, memoryID string) (*MemoryResult, error)
}

type ContextdToolCall struct {
	Timestamp time.Time
	SessionID string
	Tool      string // memory_search, memory_record, memory_feedback, etc.
	Input     map[string]interface{}
	Success   bool
	Output    string
}

type ConversationEntry struct {
	Type       string          `json:"type"`
	UUID       string          `json:"uuid"`
	ParentUUID *string         `json:"parentUuid"`
	SessionID  string          `json:"sessionId"`
	Timestamp  time.Time       `json:"timestamp"`
	Message    json.RawMessage `json:"message"`
	UserType   string          `json:"userType"`
	GitBranch  string          `json:"gitBranch"`
	CWD        string          `json:"cwd"`
	Summary    string          `json:"summary,omitempty"`
	ToolResult json.RawMessage `json:"toolUseResult,omitempty"`
}

type ConversationStats struct {
	SessionID         string
	StartTime         time.Time
	EndTime           time.Time
	Duration          time.Duration
	UserMessages      int
	AssistantMessages int
	ToolCalls         int
	ContextdToolCalls []ContextdToolCall
	MemorySearches    int
	MemoryRecords     int
	MemoryFeedbacks   int
	CheckpointSaves   int
	CheckpointResumes int
	Errors            int
}

type FeedbackEvent struct {
	Timestamp time.Time `json:"timestamp"`
	MemoryID  string    `json:"memory_id"`
	Helpful   bool      `json:"helpful"`
	Reasoning string    `json:"reasoning,omitempty"`
}

type LLMClient interface {
	Generate(ctx context.Context, systemPrompt, userPrompt string) (string, error)
	GenerateStructured(ctx context.Context, systemPrompt, userPrompt string, schema interface{}) (interface{}, error)
}

type MemoryResult struct {
	ID         string   `json:"id"`
	Title      string   `json:"title"`
	Content    string   `json:"content"`
	Outcome    string   `json:"outcome"`
	Confidence float64  `json:"confidence"`
	Tags       []string `json:"tags"`
}

type MessageContent struct {
	Role    string      `json:"role"`
	Content interface{} `json:"content"` // Can be string or []ContentBlock
	Model   string      `json:"model,omitempty"`
}

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

type OutcomeEvent struct {
	Timestamp time.Time `json:"timestamp"`
	MemoryID  string    `json:"memory_id"`
	Succeeded bool      `json:"succeeded"`
	SessionID string    `json:"session_id,omitempty"`
	TaskDesc  string    `json:"task_description,omitempty"`
}

type Persona struct {
	// Name identifies this persona for logging
	Name string `json:"name"`

	// Description is passed to the LLM to guide behavior
	Description string `json:"description"`

	// Goals are what the persona is trying to accomplish
	Goals []string `json:"goals"`

	// Constraints limit how the persona behaves
	Constraints []string `json:"constraints"`

	// FeedbackStyle influences how the persona rates memories
	// Options: "generous", "critical", "realistic", "random"
	FeedbackStyle string `json:"feedback_style"`

	// SuccessRate is the probability tasks succeed (0.0-1.0)
	// Used for outcome signal generation
	SuccessRate float64 `json:"success_rate"`
}

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

type RunnerConfig struct {
	Client ContextdClient
	LLM    LLMClient
	Logger *zap.Logger
}

type Scenario struct {
	// Name identifies the scenario
	Name string `json:"name"`

	// Description explains what this scenario tests
	Description string `json:"description"`

	// Persona to use for this scenario
	Persona Persona `json:"persona"`

	// ProjectID for contextd operations
	ProjectID string `json:"project_id"`

	// MaxTurns limits the conversation length
	MaxTurns int `json:"max_turns"`

	// Actions defines the sequence of actions to take
	// If empty, agent decides autonomously via LLM
	Actions []Action `json:"actions,omitempty"`

	// Assertions to check after scenario completes
	Assertions []Assertion `json:"assertions"`
}

type Session struct {
	ID        string          `json:"id"`
	Persona   Persona         `json:"persona"`
	ProjectID string          `json:"project_id"`
	StartTime time.Time       `json:"start_time"`
	EndTime   time.Time       `json:"end_time"`
	Turns     []Turn          `json:"turns"`
	Feedback  []FeedbackEvent `json:"feedback"`
	Outcomes  []OutcomeEvent  `json:"outcomes"`
	Metrics   SessionMetrics  `json:"metrics"`
}

type SessionMetrics struct {
	MemoriesRecorded   int     `json:"memories_recorded"`
	MemoriesRetrieved  int     `json:"memories_retrieved"`
	FeedbackGiven      int     `json:"feedback_given"`
	PositiveFeedback   int     `json:"positive_feedback"`
	OutcomesRecorded   int     `json:"outcomes_recorded"`
	SuccessfulOutcomes int     `json:"successful_outcomes"`
	AvgConfidenceDelta float64 `json:"avg_confidence_delta"`
}

type TestResult struct {
	Scenario   string         `json:"scenario"`
	Passed     bool           `json:"passed"`
	Session    *Session       `json:"session"`
	Assertions []AssertResult `json:"assertions"`
	Error      string         `json:"error,omitempty"`
	Duration   time.Duration  `json:"duration"`
}

type ToolCall struct {
	Name   string                 `json:"name"`
	Args   map[string]interface{} `json:"args"`
	Result interface{}            `json:"result,omitempty"`
	Error  string                 `json:"error,omitempty"`
}

type ToolUseBlock struct {
	ID    string          `json:"id"`
	Name  string          `json:"name"`
	Input json.RawMessage `json:"input"`
}

type Turn struct {
	Timestamp time.Time  `json:"timestamp"`
	Role      string     `json:"role"` // "user" or "assistant"
	Content   string     `json:"content"`
	ToolCalls []ToolCall `json:"tool_calls,omitempty"`
}