From a35c176b4262a61d767a6ae78b64945fea0266ca Mon Sep 17 00:00:00 2001 From: Steve Dudenhoeffer Date: Sun, 28 Jun 2026 00:37:53 -0400 Subject: [PATCH 1/2] run: fold inv.Images into the initial user message (multimodal opening turn) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The executor passed only the text `input` to majordomo's agent.Run, silently dropping inv.Images — so a multimodal run (vision: chatbot @mention, chat API) lost its images on the executus path. majordomo's Run input arg is text-only, so fold the images into the first user message (text + image parts) via WithHistory and call Run with empty input, mirroring mort agentexec's multimodal seeding. The image-less path is unchanged (prompt passes straight through). Tests: a run with Images carries the image bytes + prompt into the first model request; the text-only path still reaches the model. Co-Authored-By: Claude Opus 4.8 (1M context) --- run/executor.go | 20 +++++++++- run/images_test.go | 93 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 112 insertions(+), 1 deletion(-) create mode 100644 run/images_test.go diff --git a/run/executor.go b/run/executor.go index 6a57330..7649157 100644 --- a/run/executor.go +++ b/run/executor.go @@ -320,7 +320,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 +440,21 @@ 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. Mirrors mort agentexec's multimodal seeding. +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) + parts = append(parts, llm.Text(input)) + for _, img := range images { + parts = append(parts, img) + } + opts = append(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..504af26 --- /dev/null +++ b/run/images_test.go @@ -0,0 +1,93 @@ +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 first request must carry a user message bearing the image bytes + prompt. + sawImage, sawText := false, false + for _, msg := range calls[0].Request.Messages { + 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 { + t.Error("initial image was not folded into the first model request (dropped)") + } + if !sawText { + t.Error("prompt text missing from the multimodal first message") + } +} + +// 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") + } +} From 0acaa8c9a56e9155f34d5f9bfcd04efc0ceba88a Mon Sep 17 00:00:00 2001 From: Steve Dudenhoeffer Date: Sun, 28 Jun 2026 01:11:15 -0400 Subject: [PATCH 2/2] run: guard empty text part in runAgent + drop cross-repo doc ref (gadfly #16) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Every reviewer flagged that runAgent appended llm.Text(input) unconditionally, so an image-only run (blank prompt) emitted an empty TextPart — inconsistent with the sibling runSession.AttachImages which guards it. Mirror that guard (strings.TrimSpace(input) != ""). Also: - copy opts before appending (variadic backing array can have spare capacity; avoid aliasing a caller's slice). - reword the doc comment to drop the mort-agentexec reference (executus is a standalone lib; a consumer name doesn't belong in its godoc). Tests: image+text are co-located in ONE user message; an image-only run emits no blank TextPart. Co-Authored-By: Claude Opus 4.8 (1M context) --- run/executor.go | 14 +++++++++++--- run/images_test.go | 40 ++++++++++++++++++++++++++++++++++------ 2 files changed, 45 insertions(+), 9 deletions(-) diff --git a/run/executor.go b/run/executor.go index 7649157..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" @@ -445,16 +446,23 @@ func detach(ctx context.Context) context.Context { // 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. Mirrors mort agentexec's multimodal seeding. +// 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) - parts = append(parts, llm.Text(input)) + if strings.TrimSpace(input) != "" { + parts = append(parts, llm.Text(input)) + } for _, img := range images { parts = append(parts, img) } - opts = append(opts, agent.WithHistory([]llm.Message{llm.UserParts(parts...)})) + // 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 index 504af26..67e6dcd 100644 --- a/run/images_test.go +++ b/run/images_test.go @@ -36,9 +36,11 @@ func TestExecutorFoldsInitialImages(t *testing.T) { if len(calls) == 0 { t.Fatal("no model calls recorded") } - // The first request must carry a user message bearing the image bytes + prompt. - sawImage, sawText := false, false + // 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: @@ -51,12 +53,38 @@ func TestExecutorFoldsInitialImages(t *testing.T) { } } } + if sawImage && sawText { + coLocated = true + } } - if !sawImage { - t.Error("initial image was not folded into the first model request (dropped)") + if !coLocated { + t.Error("image + prompt text were not folded into the SAME user message") } - if !sawText { - t.Error("prompt text missing from the multimodal first 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") + } + } } }