diff --git a/run/executor.go b/run/executor.go index 6a57330..c5bd97f 100644 --- a/run/executor.go +++ b/run/executor.go @@ -4,6 +4,7 @@ import ( "context" "errors" "fmt" + "strings" "time" "gitea.stevedudenhoeffer.com/steve/majordomo/agent" @@ -320,7 +321,7 @@ func (e *Executor) Run(ctx context.Context, ra RunnableAgent, inv tool.Invocatio // One WithSteer drains BOTH the session mailbox (a tool's AttachImages) and // the critic's nudges before each step. steer := func() []llm.Message { return append(mailbox.drain(), critic.drainSteer()...) } - runRes, runErr := ag.Run(runCtx, input, agent.WithSteer(steer)) + runRes, runErr := runAgent(runCtx, ag, input, inv.Images, agent.WithSteer(steer)) status := statusFor(runCtx, runErr) if runRes != nil { @@ -440,3 +441,28 @@ func detach(ctx context.Context) context.Context { _ = cancel // bounded by the timeout; nothing to cancel early return c } + +// runAgent dispatches the majordomo agent loop. majordomo's Run takes a text-only +// input arg, so when the invocation carries images they're folded into the first +// user message (text + image parts) via WithHistory and Run is called with an +// empty input — the model then sees a multimodal opening turn. The image-less path +// passes the prompt straight through. +// +// The text part is omitted when input is blank (image-only run), matching +// runSession.AttachImages so no empty TextPart is sent. +func runAgent(ctx context.Context, ag *agent.Agent, input string, images []llm.ImagePart, opts ...agent.RunOption) (*agent.Result, error) { + if len(images) == 0 { + return ag.Run(ctx, input, opts...) + } + parts := make([]llm.Part, 0, len(images)+1) + if strings.TrimSpace(input) != "" { + parts = append(parts, llm.Text(input)) + } + for _, img := range images { + parts = append(parts, img) + } + // Copy opts before appending so a caller-supplied backing array is never + // mutated/aliased (the variadic slice can have spare capacity). + opts = append(opts[:len(opts):len(opts)], agent.WithHistory([]llm.Message{llm.UserParts(parts...)})) + return ag.Run(ctx, "", opts...) +} diff --git a/run/images_test.go b/run/images_test.go new file mode 100644 index 0000000..67e6dcd --- /dev/null +++ b/run/images_test.go @@ -0,0 +1,121 @@ +package run_test + +import ( + "context" + "strings" + "testing" + + "gitea.stevedudenhoeffer.com/steve/majordomo/llm" + "gitea.stevedudenhoeffer.com/steve/majordomo/provider/fake" + + "gitea.stevedudenhoeffer.com/steve/executus/run" + "gitea.stevedudenhoeffer.com/steve/executus/tool" +) + +// TestExecutorFoldsInitialImages: when the invocation carries Images, they're +// folded into the first user message (alongside the prompt text) instead of being +// dropped — majordomo's Run input arg is text-only, so the executor seeds the +// multimodal opening turn via history. +func TestExecutorFoldsInitialImages(t *testing.T) { + fp := fake.New("fake") + fp.Enqueue("m", fake.Reply("saw the image")) + m, _ := fp.Model("m") + + img := llm.ImagePart{MIME: "image/png", Data: []byte("PNGDATA")} + inv := tool.Invocation{RunID: "r1", Images: []llm.ImagePart{img}} + ex := run.New(run.Config{ + Registry: tool.NewRegistry(), + Models: func(ctx context.Context, _ string) (context.Context, llm.Model, error) { return ctx, m, nil }, + }) + res := ex.Run(context.Background(), run.RunnableAgent{ModelTier: "m"}, inv, "describe this") + if res.Err != nil { + t.Fatalf("run error: %v", res.Err) + } + + calls := fp.Calls() + if len(calls) == 0 { + t.Fatal("no model calls recorded") + } + // The text + image must be CO-LOCATED in a single user message (not split + // across two), so the model reads them as one multimodal turn. + coLocated := false + for _, msg := range calls[0].Request.Messages { + sawImage, sawText := false, false + for _, p := range msg.Parts { + switch pp := p.(type) { + case llm.ImagePart: + if string(pp.Data) == "PNGDATA" { + sawImage = true + } + case llm.TextPart: + if strings.Contains(pp.Text, "describe this") { + sawText = true + } + } + } + if sawImage && sawText { + coLocated = true + } + } + if !coLocated { + t.Error("image + prompt text were not folded into the SAME user message") + } +} + +// TestExecutorImageOnlyNoBlankText: an image-only run (blank prompt) must NOT emit +// an empty TextPart — the message carries just the image, matching +// runSession.AttachImages's guard. +func TestExecutorImageOnlyNoBlankText(t *testing.T) { + fp := fake.New("fake") + fp.Enqueue("m", fake.Reply("saw it")) + m, _ := fp.Model("m") + + inv := tool.Invocation{RunID: "r3", Images: []llm.ImagePart{{MIME: "image/png", Data: []byte("IMG")}}} + ex := run.New(run.Config{ + Registry: tool.NewRegistry(), + Models: func(ctx context.Context, _ string) (context.Context, llm.Model, error) { return ctx, m, nil }, + }) + res := ex.Run(context.Background(), run.RunnableAgent{ModelTier: "m"}, inv, " ") + if res.Err != nil { + t.Fatalf("run error: %v", res.Err) + } + for _, msg := range fp.Calls()[0].Request.Messages { + for _, p := range msg.Parts { + if tp, ok := p.(llm.TextPart); ok && strings.TrimSpace(tp.Text) == "" { + t.Error("image-only run emitted a blank TextPart") + } + } + } +} + +// TestExecutorTextOnlyUnchanged: with no Images, the prompt flows through as the +// text input (regression guard that the fold path didn't break the common case). +func TestExecutorTextOnlyUnchanged(t *testing.T) { + fp := fake.New("fake") + fp.Enqueue("m", fake.Reply("ok")) + m, _ := fp.Model("m") + + ex := run.New(run.Config{ + Registry: tool.NewRegistry(), + Models: func(ctx context.Context, _ string) (context.Context, llm.Model, error) { return ctx, m, nil }, + }) + res := ex.Run(context.Background(), run.RunnableAgent{ModelTier: "m"}, tool.Invocation{RunID: "r2"}, "plain prompt") + if res.Err != nil { + t.Fatalf("run error: %v", res.Err) + } + calls := fp.Calls() + if len(calls) == 0 { + t.Fatal("no model calls recorded") + } + sawText := false + for _, msg := range calls[0].Request.Messages { + for _, p := range msg.Parts { + if tp, ok := p.(llm.TextPart); ok && strings.Contains(tp.Text, "plain prompt") { + sawText = true + } + } + } + if !sawText { + t.Error("text-only prompt did not reach the model") + } +}