From a35c176b4262a61d767a6ae78b64945fea0266ca Mon Sep 17 00:00:00 2001 From: Steve Dudenhoeffer Date: Sun, 28 Jun 2026 00:37:53 -0400 Subject: [PATCH] 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") + } +}