package runs import ( "context" "encoding/json/jsontext" json "encoding/json/v2" "fmt" "strings" "time" "github.com/google/uuid" "github.com/samcharles93/ai-sdk/agentloop" "github.com/samcharles93/ai-sdk/core" "github.com/samcharles93/archie-core/internal/platform/prompts" "github.com/samcharles93/archie-core/modules/judgement" "github.com/samcharles93/archie-core/modules/memory" ) // Memory stores and retrieves incident history for an investigation target. type Memory interface { Past(ctx context.Context, runID uuid.UUID, t memory.Target) ([]memory.Incident, error) Record(ctx context.Context, runID uuid.UUID, event jsontext.Value, t memory.Target, cause, summary string) error Finish(ctx context.Context, runID uuid.UUID, actions []memory.Action, threshold int) (memory.Review, error) } var recordCauseBudget = agentloop.Budget{MaxSteps: 4, MaxTokens: 30_000, WallClock: 3 * time.Minute} // maxRecalled is how many earlier incidents the agent is shown. const maxRecalled = 10 const targetSchema = `{"type":"object","properties":{ "target_kind":{"type":"string","description":"the resource type, such as host"}, "target_id":{"type":"string","description":"the resource ID, such as web-1"}}, "required":["target_kind","target_id"]}` const causeSchema = `{"type":"object","properties":{ "target_kind":{"type":"string","description":"the resource type, such as host"}, "target_id":{"type":"string","description":"the resource ID, such as web-1"}, "cause":{"type":"string","description":"two to four lowercase words joined by hyphens, such as disk-pressure"}, "summary":{"type":"string","description":"one sentence: what happened and why"}}, "required":["target_kind","target_id","cause","summary"]}` type targetInput struct { Kind string `json:"target_kind"` ID string `json:"target_id"` } type causeInput struct { targetInput Cause string `json:"cause"` Summary string `json:"summary"` } func pastIncidentsTool(mem Memory, runID uuid.UUID) *core.Tool { return &core.Tool{ Name: "memory_past_incidents", Description: "Lists previous incidents for a target, including dates, causes, actions and outcomes.", Parameters: []byte(targetSchema), Execute: func(ctx context.Context, input string) (string, error) { var in targetInput if err := json.Unmarshal([]byte(input), &in); err != nil { return "", fmt.Errorf("read input: %w", err) } past, err := mem.Past(ctx, runID, memory.Target{Kind: in.Kind, ID: in.ID}) if err != nil { return "", err } if len(past) == 0 { return "no earlier incidents on this target", nil } past = past[:min(len(past), maxRecalled)] lines := make([]string, 0, len(past)) for _, p := range past { lines = append(lines, p.Line()) } return strings.Join(lines, "\n"), nil }, } } // recordCause uses a separate turn because small models are more reliable // when asked for four fields after reporting than when asked to remember // a tool call throughout the investigation. func recordCause(rc *Context, mem Memory, input jsontext.Value, res AgentResult, req AgentRequest) error { if !res.Completed { return nil } // The prompt is part of the journaled request digest, so its key order must be the same on replay. prompt, err := json.Marshal(map[string]any{"event": input, "findings": res.Answer}, json.Deterministic(true)) if err != nil { return err } req.Name, req.System, req.Prompt, req.Budget = "record-cause", prompts.RecordCause(), string(prompt), recordCauseBudget req.Tools = core.ToolSet{"record_cause": { Name: "record_cause", Description: "Records the incident target, cause and summary.", Parameters: []byte(causeSchema), Execute: func(ctx context.Context, raw string) (string, error) { var in causeInput if err := json.Unmarshal([]byte(raw), &in); err != nil { return "", fmt.Errorf("read input: %w", err) } if err := mem.Record(ctx, rc.RunID(), input, memory.Target{Kind: in.Kind, ID: in.ID}, in.Cause, in.Summary); err != nil { return "", err } return "recorded", nil }, }} // If the agent records no incident, keep the investigation findings. _, err = rc.Agent(req) return err } // incidentActions lists what the run did: each action judged, once, with how it // ended. func incidentActions(decisions []judgement.Decision, outcomes []approvalOutcome) []memory.Action { byDigest := make(map[string]approvalOutcome, len(outcomes)) for _, o := range outcomes { byDigest[o.digest] = o } seen := make(map[string]bool, len(decisions)) out := make([]memory.Action, 0, len(decisions)) for _, d := range decisions { if seen[d.Action.Digest] { continue } seen[d.Action.Digest] = true a := memory.Action{Action: d.Action.Connector + " " + d.Action.Name, Target: d.Action.Target.Kind + ":" + d.Action.Target.ID} switch o, held := byDigest[d.Action.Digest]; { case held: a.State, a.Detail = o.State, firstText(o.Error, o.Result) if o.Unknown { a.State = "outcome unknown" } case d.Level == judgement.Never: a.State = "refused" case d.Level.Runs(): a.State = "ran" default: a.State = "held" } out = append(out, a) } return out } func firstText(parts ...string) string { for _, p := range parts { if p != "" { return p } } return "" } // remember records the incident and checks whether it meets the recurrence // threshold for proposing a root-cause fix. func remember(rc *Context, mem Memory, judge Judge, outcomes []approvalOutcome, threshold int) (memory.Review, error) { return rc.Step("remember", func(ctx context.Context, _ string) (memory.Review, error) { decisions, err := judge.ForRun(ctx, rc.RunID()) if err != nil { return memory.Review{}, err } return mem.Finish(ctx, rc.RunID(), incidentActions(decisions, outcomes), threshold) }) } // recurrenceLines is the findings' note on a cause that has come back: that it // has, and the root-cause fix asked for. func recurrenceLines(r memory.Review) string { if r.Proposal == "" { return "" } return fmt.Sprintf("Root-cause fix proposed (this is incident %d with this cause): %s", r.Repeats, r.Proposal) }