Fully autonomous AI Agents system capable of performing complex penetration testing tasks
Go ai-agentsai-security-toolanthropicautonomous-agentsgolanggptgraphqlmulti-agent-systemoffensive-securityopen-sourceopenaipenetration-testingpenetration-testing-toolsreactsecurity-automationsecurity-testingsecurity-toolsself-hosted
fix: apply custom prompts to new sessions
mason505208c050ce216d
diff --git a/backend/pkg/controller/assistant.go b/backend/pkg/controller/assistant.goindex 3f41906a..4627b991 100644--- a/backend/pkg/controller/assistant.go+++ b/backend/pkg/controller/assistant.go@@ -16,7 +16,6 @@ import ("pentagi/pkg/providers""pentagi/pkg/providers/pconfig""pentagi/pkg/providers/provider"- "pentagi/pkg/templates""pentagi/pkg/tools""github.com/sirupsen/logrus"@@ -154,7 +153,10 @@ func NewAssistantWorker(ctx context.Context, awc newAssistantWorkerCtx) (Assistareturn nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow assistant log worker", err)}- prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB+ prompter, err := newUserPrompter(ctx, awc.db, awc.userID)+ if err != nil {+ return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to build user prompter", err)+ }executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, awc.functions, awc.flowID)if err != nil {return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow tools executor", err)@@ -319,7 +321,10 @@ func LoadAssistantWorker(return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow assistant log worker", err)}- prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB+ prompter, err := newUserPrompter(ctx, awc.db, awc.userID)+ if err != nil {+ return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to build user prompter", err)+ }executor, err := tools.NewFlowToolsExecutor(awc.db, awc.cfg, awc.docker, functions, awc.flowID)if err != nil {return nil, wrapErrorEndSpan(ctx, assistantSpan, "failed to create flow tools executor", err)diff --git a/backend/pkg/controller/flow.go b/backend/pkg/controller/flow.goindex e8909ffe..ce167089 100644--- a/backend/pkg/controller/flow.go+++ b/backend/pkg/controller/flow.go@@ -19,7 +19,6 @@ import ("pentagi/pkg/providers""pentagi/pkg/providers/pconfig""pentagi/pkg/providers/provider"- "pentagi/pkg/templates""pentagi/pkg/tools""github.com/sirupsen/logrus"@@ -166,7 +165,10 @@ func NewFlowWorker(flowSpan := observation.Span(langfuse.WithSpanName("prepare flow worker"))ctx, _ = flowSpan.Observation(ctx)- prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB+ prompter, err := newUserPrompter(ctx, fwc.db, fwc.userID)+ if err != nil {+ return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to build user prompter", err)+ }executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, fwc.functions, flow.ID)if err != nil {return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to create flow tools executor", err)@@ -332,7 +334,10 @@ func LoadFlowWorker(ctx context.Context, flow database.Flow, fwc flowWorkerCtx)return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to unmarshal functions", err)}- prompter := templates.NewDefaultPrompter() // TODO: change to flow prompter by userID from DB+ prompter, err := newUserPrompter(ctx, fwc.db, flow.UserID)+ if err != nil {+ return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to build user prompter", err)+ }executor, err := tools.NewFlowToolsExecutor(fwc.db, fwc.cfg, fwc.docker, functions, flow.ID)if err != nil {return nil, wrapErrorEndSpan(ctx, flowSpan, "failed to create flow tools executor", err)diff --git a/backend/pkg/controller/prompter.go b/backend/pkg/controller/prompter.gonew file mode 100644index 00000000..76376fda--- /dev/null+++ b/backend/pkg/controller/prompter.go@@ -0,0 +1,53 @@+package controller++import (+ "context"+ "encoding/json"+ "fmt"++ "pentagi/pkg/database"+ "pentagi/pkg/templates"+)++// newUserPrompter loads the user's custom prompts from the database and+// overlays them onto the compiled default templates. Prompt types that+// the user has not customized continue to use the defaults. A database+// error is returned to the caller so that session creation fails+// explicitly instead of silently falling back to defaults.+func newUserPrompter(ctx context.Context, db database.Querier, userID int64) (templates.Prompter, error) {+ userPrompts, err := db.GetUserPrompts(ctx, userID)+ if err != nil {+ return nil, fmt.Errorf("failed to load user prompts: %w", err)+ }+ return buildUserPrompter(templates.NewDefaultPrompter(), userPrompts)+}++// buildUserPrompter is the pure merge step extracted from newUserPrompter+// so it can be unit-tested without a database fake. It seeds the result+// with every default template and then overrides each prompt type the+// user has saved a non-empty body for.+func buildUserPrompter(defaults templates.Prompter, userPrompts []database.Prompt) (templates.Prompter, error) {+ blob, err := defaults.DumpTemplates()+ if err != nil {+ return nil, fmt.Errorf("failed to dump default templates: %w", err)+ }++ merged := templates.PromptsMap{}+ if err := json.Unmarshal(blob, &merged); err != nil {+ return nil, fmt.Errorf("failed to parse default templates: %w", err)+ }++ for _, p := range userPrompts {+ if p.Prompt == "" {+ // The Prompts UI uses delete (or reset, which writes the+ // default body back) to remove a customization, so an empty+ // body is unexpected. Skip it instead of clobbering the+ // default with an empty string that would later surface as+ // ErrTemplateNotFound deep inside agent rendering.+ continue+ }+ merged[templates.PromptType(p.Type)] = p.Prompt+ }++ return templates.NewFlowPrompter(merged), nil+}diff --git a/backend/pkg/controller/prompter_test.go b/backend/pkg/controller/prompter_test.gonew file mode 100644index 00000000..e744ab4e--- /dev/null+++ b/backend/pkg/controller/prompter_test.go@@ -0,0 +1,211 @@+package controller++import (+ "context"+ "errors"+ "testing"++ "pentagi/pkg/database"+ "pentagi/pkg/templates"+)++// fakeQuerier satisfies database.Querier by embedding the interface+// (so the unused methods stay nil) and overrides only GetUserPrompts.+// Calling any other method would panic, which is exactly what we want+// for a unit test that should not touch unrelated DB code.+type fakeQuerier struct {+ database.Querier+ prompts []database.Prompt+ err error+}++func (f *fakeQuerier) GetUserPrompts(ctx context.Context, userID int64) ([]database.Prompt, error) {+ if f.err != nil {+ return nil, f.err+ }+ return f.prompts, nil+}++// getDefaultTemplate returns the compiled default body for a prompt+// type, used to compare overridden vs. preserved prompts in tests.+func getDefaultTemplate(t *testing.T, pt templates.PromptType) string {+ t.Helper()+ body, err := templates.NewDefaultPrompter().GetTemplate(pt)+ if err != nil {+ t.Fatalf("default prompter has no template for %q: %v", pt, err)+ }+ return body+}++func TestBuildUserPrompter_NoUserPrompts(t *testing.T) {+ defaults := templates.NewDefaultPrompter()+ prompter, err := buildUserPrompter(defaults, nil)+ if err != nil {+ t.Fatalf("buildUserPrompter returned error: %v", err)+ }++ for _, pt := range []templates.PromptType{+ templates.PromptTypePrimaryAgent,+ templates.PromptTypeAssistant,+ } {+ got, err := prompter.GetTemplate(pt)+ if err != nil {+ t.Fatalf("GetTemplate(%q) error: %v", pt, err)+ }+ want := getDefaultTemplate(t, pt)+ if got != want {+ t.Errorf("prompt %q: expected default body when user has no overrides, got divergent body", pt)+ }+ }+}++func TestBuildUserPrompter_SingleOverride(t *testing.T) {+ const customBody = "custom primary agent prompt body"+ userPrompts := []database.Prompt{+ {Type: database.PromptTypePrimaryAgent, Prompt: customBody},+ }++ prompter, err := buildUserPrompter(templates.NewDefaultPrompter(), userPrompts)+ if err != nil {+ t.Fatalf("buildUserPrompter error: %v", err)+ }++ got, err := prompter.GetTemplate(templates.PromptTypePrimaryAgent)+ if err != nil {+ t.Fatalf("GetTemplate(primary_agent) error: %v", err)+ }+ if got != customBody {+ t.Errorf("primary_agent: expected custom body %q, got %q", customBody, got)+ }++ // Spot-check that an unrelated type still resolves to the default.+ for _, pt := range []templates.PromptType{+ templates.PromptTypeAssistant,+ templates.PromptTypePentester,+ } {+ got, err := prompter.GetTemplate(pt)+ if err != nil {+ t.Fatalf("GetTemplate(%q) error: %v", pt, err)+ }+ if got != getDefaultTemplate(t, pt) {+ t.Errorf("prompt %q should still match default after a single unrelated override", pt)+ }+ }+}++func TestBuildUserPrompter_PartialOverridesPreserveDefaults(t *testing.T) {+ overrides := map[database.PromptType]string{+ database.PromptTypePrimaryAgent: "custom primary",+ database.PromptTypeCoder: "custom coder",+ database.PromptTypeReporter: "custom reporter",+ }++ userPrompts := make([]database.Prompt, 0, len(overrides))+ for pt, body := range overrides {+ userPrompts = append(userPrompts, database.Prompt{Type: pt, Prompt: body})+ }++ prompter, err := buildUserPrompter(templates.NewDefaultPrompter(), userPrompts)+ if err != nil {+ t.Fatalf("buildUserPrompter error: %v", err)+ }++ for pt, want := range overrides {+ got, err := prompter.GetTemplate(templates.PromptType(pt))+ if err != nil {+ t.Fatalf("GetTemplate(%q) error: %v", pt, err)+ }+ if got != want {+ t.Errorf("prompt %q: expected custom body %q, got %q", pt, want, got)+ }+ }++ // Types that were not overridden must still match the defaults.+ for _, pt := range []templates.PromptType{+ templates.PromptTypeAssistant,+ templates.PromptTypePentester,+ templates.PromptTypeSearcher,+ } {+ got, err := prompter.GetTemplate(pt)+ if err != nil {+ t.Fatalf("GetTemplate(%q) error: %v", pt, err)+ }+ if got != getDefaultTemplate(t, pt) {+ t.Errorf("prompt %q should still match default after partial overrides", pt)+ }+ }+}++func TestBuildUserPrompter_EmptyBodyIsIgnored(t *testing.T) {+ userPrompts := []database.Prompt{+ {Type: database.PromptTypePrimaryAgent, Prompt: ""},+ }++ prompter, err := buildUserPrompter(templates.NewDefaultPrompter(), userPrompts)+ if err != nil {+ t.Fatalf("buildUserPrompter error: %v", err)+ }++ got, err := prompter.GetTemplate(templates.PromptTypePrimaryAgent)+ if err != nil {+ t.Fatalf("GetTemplate(primary_agent) error: %v", err)+ }+ if got != getDefaultTemplate(t, templates.PromptTypePrimaryAgent) {+ t.Errorf("primary_agent: empty user body must not clobber default")+ }+}++func TestNewUserPrompter_HappyPath(t *testing.T) {+ const customAssistant = "custom assistant prompt"+ const customCoder = "custom coder prompt"++ db := &fakeQuerier{+ prompts: []database.Prompt{+ {Type: database.PromptTypeAssistant, Prompt: customAssistant},+ {Type: database.PromptTypeCoder, Prompt: customCoder},+ },+ }++ prompter, err := newUserPrompter(context.Background(), db, 42)+ if err != nil {+ t.Fatalf("newUserPrompter error: %v", err)+ }++ for pt, want := range map[templates.PromptType]string{+ templates.PromptTypeAssistant: customAssistant,+ templates.PromptTypeCoder: customCoder,+ } {+ got, err := prompter.GetTemplate(pt)+ if err != nil {+ t.Fatalf("GetTemplate(%q) error: %v", pt, err)+ }+ if got != want {+ t.Errorf("prompt %q: expected custom body %q, got %q", pt, want, got)+ }+ }++ // Sanity check that an un-customized type still falls back.+ got, err := prompter.GetTemplate(templates.PromptTypePentester)+ if err != nil {+ t.Fatalf("GetTemplate(pentester) error: %v", err)+ }+ if got != getDefaultTemplate(t, templates.PromptTypePentester) {+ t.Errorf("pentester: expected default body when user has no override")+ }+}++func TestNewUserPrompter_DBErrorPropagates(t *testing.T) {+ sentinel := errors.New("db connection lost")+ db := &fakeQuerier{err: sentinel}++ prompter, err := newUserPrompter(context.Background(), db, 42)+ if err == nil {+ t.Fatalf("expected error, got nil prompter=%v", prompter)+ }+ if prompter != nil {+ t.Errorf("expected nil prompter on DB error, got %v", prompter)+ }+ if !errors.Is(err, sentinel) {+ t.Errorf("expected wrapped sentinel error, got %v", err)+ }+}