fix atlascloud multi-step tool followups

Co-authored-by: Codex <codex@openai.com>

.github/loop/PRIORITIES.md

@@ -21,7 +21,9 @@ changes, architectural rewrites. Those go to the human.
 
 ## Work queue (ranked)
 
-1. **Add examples wayfinding index for first-agent adoption** ([#4223](https://github.com/micro/go-micro/issues/4223)) — keep developer adoption weighted with internal hardening: the README and getting-started guide now have a stronger first-agent path, but examples remain spread across docs, CLI output, and directories. A single CI-guarded examples map should make the smallest no-secret agent, the 0→hero support app, and next interop examples discoverable from one place.
+1. **Make AtlasCloud plan-delegate complete the required notify side effect** ([#4255](https://github.com/micro/go-micro/issues/4255)) — Now-phase getting-started contract and cross-provider conformance overlap here: the live AtlasCloud 0→hero plan/delegate harness can now parse the initial plan call, but still exits before the required task and notify side effects, so a provider-backed services → agents → workflows path is not yet reliable.
+2. **Link examples wayfinding from website getting-started path** ([#4241](https://github.com/micro/go-micro/issues/4241)) — keep adoption weighted with hardening after the examples index shipped: the repo README and CLI now point at the first-agent/0→hero map, but go-micro.dev getting-started and quickstart pages still skip the examples index/support reference links that make the no-secret on-ramp discoverable.
+3. **Make AtlasCloud guarded delegation pass reliably** ([#4244](https://github.com/micro/go-micro/issues/4244)) — Now-phase cross-provider conformance remains important after the Minimax request-shape fallback, duplicate delegated-notification replay fixes, and OpenAI-compatible text tool-call parsing shipped; keep it in queue until the live agent harness consistently observes the guarded delegate within the retry budget.
 
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._

agent/agent.go

@@ -99,6 +99,12 @@ type agentImpl struct {
 	// holding mu. Tool execution updates it so resumed runs can reuse
 	// completed tool results without replaying side effects.
 	currentRun *flow.Run
+
+	// delegateCalls collapses concurrent equivalent delegate tool calls so a
+	// provider replay cannot fan out duplicate delegated side effects before the
+	// durable delegate-result cache is written.
+	delegateMu    sync.Mutex
+	delegateCalls map[string]*delegateCall
 }
 
 // New creates a new Agent.

agent/builtin.go

@@ -27,6 +27,11 @@ const (
 	toolHumanInput = "request_input"
 )
 
+type delegateCall struct {
+	done chan struct{}
+	res  ai.ToolResult
+}
+
 // builtinTools returns the tool definitions exposed to the model in
 // addition to the agent's scoped service tools.
 func builtinTools() []ai.Tool {
@@ -585,7 +590,7 @@ func (a *agentImpl) handleHumanInput(call ai.ToolCall) ai.ToolResult {
 // if 'to' names a registered agent, it is called via RPC. Otherwise an
 // ephemeral sub-agent is created with a fresh, isolated context, asked
 // the subtask, and its reply returned.
-func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.ToolResult {
+func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res ai.ToolResult) {
 	input := call.Input
 	task, _ := input["task"].(string)
 	if task == "" {
@@ -596,6 +601,12 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.Too
 		return cached
 	}
 
+	key := delegateResultKey(to, task)
+	if cached, ok := a.joinDelegateCall(ctx, call.ID, key); ok {
+		return cached
+	}
+	defer func() { a.finishDelegateCall(key, res) }()
+
 	// An external agent on another framework, addressed by A2A URL.
 	if strings.HasPrefix(to, "http://") || strings.HasPrefix(to, "https://") {
 		reply, err := a2a.NewClient(to).Send(ctx, task)
@@ -647,6 +658,38 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.Too
 	return a.storeDelegateResult(call.ID, to, task, map[string]any{"reply": resp.Reply})
 }
 
+func (a *agentImpl) joinDelegateCall(ctx context.Context, id, key string) (ai.ToolResult, bool) {
+	a.delegateMu.Lock()
+	if a.delegateCalls == nil {
+		a.delegateCalls = map[string]*delegateCall{}
+	}
+	if inFlight := a.delegateCalls[key]; inFlight != nil {
+		a.delegateMu.Unlock()
+		select {
+		case <-ctx.Done():
+			return errResult(id, ctx.Err().Error()), true
+		case <-inFlight.done:
+			return withToolResultID(inFlight.res, id), true
+		}
+	}
+	a.delegateCalls[key] = &delegateCall{done: make(chan struct{})}
+	a.delegateMu.Unlock()
+	return ai.ToolResult{}, false
+}
+
+func (a *agentImpl) finishDelegateCall(key string, res ai.ToolResult) {
+	a.delegateMu.Lock()
+	inFlight := a.delegateCalls[key]
+	if inFlight == nil {
+		a.delegateMu.Unlock()
+		return
+	}
+	inFlight.res = res
+	delete(a.delegateCalls, key)
+	close(inFlight.done)
+	a.delegateMu.Unlock()
+}
+
 func (a *agentImpl) cachedDelegateResult(id, to, task string) (ai.ToolResult, bool) {
 	recs, err := a.stateStore().Read(delegateResultKey(to, task))
 	if err != nil || len(recs) == 0 {
@@ -666,6 +709,11 @@ func (a *agentImpl) storeDelegateResult(id, to, task string, out map[string]any)
 	return ai.ToolResult{ID: id, Value: out, Content: string(b)}
 }
 
+func withToolResultID(res ai.ToolResult, id string) ai.ToolResult {
+	res.ID = id
+	return res
+}
+
 func delegateResultKey(to, task string) string {
 	fp := normalizeDelegateTarget(to) + "\x00" + normalizeDelegateTask(task)
 	sum := sha256.Sum256([]byte(fp))

agent/builtin_test.go

@@ -3,7 +3,9 @@ package agent
 import (
 	"context"
 	"encoding/json"
+	"sync"
 	"testing"
+	"time"
 
 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/registry"
@@ -207,6 +209,44 @@ func TestDelegateResultCacheReusesLaunchReadinessParaphrases(t *testing.T) {
 	}
 }
 
+func TestDelegateInFlightReplaysShareFirstResult(t *testing.T) {
+	a := New(Name("planner"), WithStore(store.NewMemoryStore())).(*agentImpl)
+	key := delegateResultKey("comms", "Notify owner@acme.com that the launch plan is ready")
+	if _, joined := a.joinDelegateCall(context.Background(), "delegate-1", key); joined {
+		t.Fatal("first delegate call unexpectedly joined an existing in-flight call")
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(1)
+	results := make(chan ai.ToolResult, 1)
+	go func() {
+		defer wg.Done()
+		res, joined := a.joinDelegateCall(context.Background(), "delegate-2", key)
+		if !joined {
+			t.Error("replayed delegate call did not join the in-flight call")
+			return
+		}
+		results <- res
+	}()
+
+	select {
+	case res := <-results:
+		t.Fatalf("replayed delegate returned before first call finished: %+v", res)
+	case <-time.After(25 * time.Millisecond):
+	}
+
+	first := ai.ToolResult{ID: "delegate-1", Content: `{"reply":"Notified owner@acme.com."}`}
+	a.finishDelegateCall(key, first)
+	wg.Wait()
+	replayed := <-results
+	if replayed.ID != "delegate-2" {
+		t.Fatalf("replayed result ID = %q, want delegate-2", replayed.ID)
+	}
+	if replayed.Content != first.Content {
+		t.Fatalf("replayed content = %q, want %q", replayed.Content, first.Content)
+	}
+}
+
 func TestIsAgent(t *testing.T) {
 	reg := registry.NewMemoryRegistry()
 

agent/text_tool_calls.go

@@ -19,7 +19,8 @@ type textToolCall struct {
 	Name      string         `json:"name"`
 	Tool      string         `json:"tool"`
 	Input     map[string]any `json:"input"`
-	Arguments map[string]any `json:"arguments"`
+	Arguments any            `json:"arguments"`
+	Function  *textToolCall  `json:"function"`
 }
 
 // executeTextToolCalls is a compatibility fallback for providers that return a
@@ -176,14 +177,7 @@ func collectTextToolCalls(v any, allowed map[string]string) []ai.ToolCall {
 			return collectTextToolCalls(nested, allowed)
 		}
 		call := mapToTextToolCall(x)
-		name := call.Name
-		if name == "" {
-			name = call.Tool
-		}
-		input := call.Input
-		if input == nil {
-			input = call.Arguments
-		}
+		name, input := textToolCallNameAndInput(call)
 		if name == "" || allowed[name] == "" || input == nil {
 			return nil
 		}
@@ -197,6 +191,40 @@ func collectTextToolCalls(v any, allowed map[string]string) []ai.ToolCall {
 	}
 }
 
+func textToolCallNameAndInput(call textToolCall) (string, map[string]any) {
+	name := call.Name
+	if name == "" {
+		name = call.Tool
+	}
+	input := call.Input
+	if input == nil {
+		input = textToolArguments(call.Arguments)
+	}
+	if call.Function != nil {
+		fnName, fnInput := textToolCallNameAndInput(*call.Function)
+		if name == "" {
+			name = fnName
+		}
+		if input == nil {
+			input = fnInput
+		}
+	}
+	return name, input
+}
+
+func textToolArguments(raw any) map[string]any {
+	switch args := raw.(type) {
+	case map[string]any:
+		return args
+	case string:
+		var input map[string]any
+		if err := json.Unmarshal([]byte(args), &input); err == nil {
+			return input
+		}
+	}
+	return nil
+}
+
 func decodeTaggedTextToolCalls(text string, allowed map[string]string) []ai.ToolCall {
 	var out []ai.ToolCall
 	for _, match := range singleTaggedToolCall.FindAllStringSubmatch(text, -1) {

agent/text_tool_calls_test.go

@@ -56,3 +56,22 @@ func TestParseTextToolCallsCreateAliasForAddTool(t *testing.T) {
 		t.Fatalf("title = %v, want Design", got)
 	}
 }
+
+func TestParseTextToolCallsOpenAICompatibleFunctionArgumentsString(t *testing.T) {
+	tools := []ai.Tool{{Name: "delegate"}}
+	reply := `<tool_call>{"id":"call-2","type":"function","function":{"name":"delegate","arguments":"{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}"}}</tool_call>`
+
+	calls := parseTextToolCalls(reply, tools)
+	if len(calls) != 1 {
+		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
+	}
+	if calls[0].Name != "delegate" {
+		t.Fatalf("call name = %q, want delegate", calls[0].Name)
+	}
+	if got := calls[0].Input["task"]; got != "summarize the conformance marker" {
+		t.Fatalf("task = %v, want summarize the conformance marker", got)
+	}
+	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
+		t.Fatalf("to = %v, want blocked-reviewer", got)
+	}
+}

ai/atlascloud/atlascloud.go

@@ -24,6 +24,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -94,6 +95,7 @@ func (p *Provider) String() string      { return "atlascloud" }
 
 func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (*ai.Response, error) {
 	tools := atlascloudTools(req.Tools)
+	compatTools, compatPrompt := atlascloudMinimaxCompatTools(p.opts.Model, req.Tools)
 
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
@@ -104,6 +106,9 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	if req.Prompt != "" {
 		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
 	}
+	if compatPrompt != "" {
+		messages = append(messages, map[string]any{"role": "system", "content": compatPrompt})
+	}
 
 	apiReq := map[string]any{
 		"model":    p.opts.Model,
@@ -119,7 +124,13 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 
 	resp, rawMessage, err := p.callAPI(ctx, "chat", apiReq)
 	if err != nil {
-		return nil, err
+		if atlascloudShouldRetryMinimaxCompat(err, compatTools) {
+			apiReq["tools"] = compatTools
+			resp, rawMessage, err = p.callAPI(ctx, "chat-minimax-compat", apiReq)
+		}
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if len(resp.ToolCalls) == 0 {
@@ -127,70 +138,77 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	}
 
 	if p.opts.ToolHandler != nil {
-		allToolCalls := append([]ai.ToolCall(nil), resp.ToolCalls...)
+		var allToolCalls []ai.ToolCall
 		var toolResults []string
+		pendingToolCalls := append([]ai.ToolCall(nil), resp.ToolCalls...)
 		followUpMessages := append(messages, map[string]any{
 			"role":       "assistant",
 			"content":    rawMessage["content"],
 			"tool_calls": rawMessage["tool_calls"],
 		})
 
-		for _, tc := range resp.ToolCalls {
-			content := p.opts.ToolHandler(ctx, tc).Content
-			if content != "" {
-				toolResults = append(toolResults, content)
-			}
-			followUpMessages = append(followUpMessages, map[string]any{
-				"role":         "tool",
-				"tool_call_id": tc.ID,
-				"content":      content,
-			})
-		}
-
-		followUpReq := map[string]any{
-			"model":    p.opts.Model,
-			"messages": followUpMessages,
-		}
-		if len(tools) > 0 {
-			// Keep the tool schema available during the follow-up turn. Minimax
-			// models behind Atlas Cloud sometimes call one required tool, inspect
-			// that result, and then issue a second tool call (for example a guarded
-			// delegate conformance check) instead of completing immediately.
-			followUpReq["tools"] = tools
-		}
-
-		followUpResp, _, err := p.callAPI(ctx, "tool-follow-up", followUpReq)
-		if err != nil {
-			return nil, err
-		}
-		if len(followUpResp.ToolCalls) > 0 {
-			for i := range followUpResp.ToolCalls {
-				result := p.opts.ToolHandler(ctx, followUpResp.ToolCalls[i])
+		for attempt := 0; len(pendingToolCalls) > 0 && attempt < 4; attempt++ {
+			for _, tc := range pendingToolCalls {
+				result := p.opts.ToolHandler(ctx, tc)
 				if result.Refused != "" {
-					followUpResp.ToolCalls[i].Error = result.Refused
+					tc.Error = result.Refused
 				}
 				if result.Content != "" {
-					followUpResp.ToolCalls[i].Result = result.Content
+					tc.Result = result.Content
 					toolResults = append(toolResults, result.Content)
 				}
+				allToolCalls = append(allToolCalls, tc)
+				resp.ToolCalls = allToolCalls
+				followUpMessages = append(followUpMessages, map[string]any{
+					"role":         "tool",
+					"tool_call_id": tc.ID,
+					"content":      result.Content,
+				})
 			}
-			allToolCalls = append(allToolCalls, followUpResp.ToolCalls...)
-			resp.ToolCalls = allToolCalls
-		}
-		if followUpResp.Reply != "" {
-			if strings.Contains(followUpResp.Reply, "<tool_call") || strings.Contains(followUpResp.Reply, "function=") {
-				// Preserve follow-up assistant content as Reply, not Answer, when
-				// it may contain a text-encoded tool call. The agent harness
-				// inspects Reply for text fallback calls after Generate returns,
-				// which covers AtlasCloud/minimax turns that emit a second
-				// required call (for example guarded delegate) as markup instead
-				// of native tool_calls.
-				resp.Reply = followUpResp.Reply
-			} else {
-				resp.Answer = followUpResp.Reply
+
+			followUpReq := map[string]any{
+				"model":    p.opts.Model,
+				"messages": followUpMessages,
 			}
-		} else if len(toolResults) > 0 {
-			resp.Answer = strings.Join(toolResults, "\n")
+			if len(tools) > 0 {
+				// Keep the tool schema available during follow-up turns. Minimax
+				// models behind Atlas Cloud sometimes complete a multi-tool task
+				// one call at a time (plan, then service tools, then delegate).
+				followUpReq["tools"] = tools
+			}
+
+			followUpResp, followUpRawMessage, err := p.callAPI(ctx, "tool-follow-up", followUpReq)
+			if err != nil {
+				if atlascloudShouldRetryWithoutTools(err, followUpReq) {
+					delete(followUpReq, "tools")
+					followUpResp, followUpRawMessage, err = p.callAPI(ctx, "tool-follow-up-no-tools", followUpReq)
+				}
+				if err != nil {
+					return nil, err
+				}
+			}
+			if len(followUpResp.ToolCalls) == 0 {
+				if followUpResp.Reply != "" {
+					if strings.Contains(followUpResp.Reply, "<tool_call") || strings.Contains(followUpResp.Reply, "function=") {
+						// Preserve follow-up assistant content as Reply, not Answer, when
+						// it may contain a text-encoded tool call. The agent harness
+						// inspects Reply for text fallback calls after Generate returns.
+						resp.Reply = followUpResp.Reply
+					} else {
+						resp.Answer = followUpResp.Reply
+					}
+				} else if len(toolResults) > 0 {
+					resp.Answer = strings.Join(toolResults, "\n")
+				}
+				break
+			}
+
+			followUpMessages = append(followUpMessages, map[string]any{
+				"role":       "assistant",
+				"content":    followUpRawMessage["content"],
+				"tool_calls": followUpRawMessage["tool_calls"],
+			})
+			pendingToolCalls = followUpResp.ToolCalls
 		}
 	}
 
@@ -308,6 +326,18 @@ func (s *atlasStream) Close() error {
 	return s.body.Close()
 }
 
+type atlascloudAPIError struct {
+	Status     string
+	StatusCode int
+	Phase      string
+	Summary    string
+	Body       string
+}
+
+func (e *atlascloudAPIError) Error() string {
+	return fmt.Sprintf("API error (%s) during atlascloud %s request (%s): %s", e.Status, e.Phase, e.Summary, e.Body)
+}
+
 func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any) (*ai.Response, map[string]any, error) {
 	reqBody, err := json.Marshal(req)
 	if err != nil {
@@ -331,7 +361,7 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, fmt.Errorf("API error (%s) during atlascloud %s request (%s): %s", httpResp.Status, phase, atlascloudRequestSummary(req), string(respBody))
+		return nil, nil, &atlascloudAPIError{Status: httpResp.Status, StatusCode: httpResp.StatusCode, Phase: phase, Summary: atlascloudRequestSummary(req), Body: string(respBody)}
 	}
 
 	var chatResp struct {
@@ -376,6 +406,50 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 	return response, rawMessage, nil
 }
 
+func atlascloudMinimaxCompatTools(model string, input []ai.Tool) ([]map[string]any, string) {
+	if !atlascloudIsMinimaxModel(model) || len(input) == 0 {
+		return nil, ""
+	}
+	var native []ai.Tool
+	var builtins []string
+	for _, tool := range input {
+		switch tool.Name {
+		case "plan", "request_input", "delegate":
+			builtins = append(builtins, tool.Name)
+		default:
+			native = append(native, tool)
+		}
+	}
+	if len(builtins) == 0 || len(native) == len(input) {
+		return nil, ""
+	}
+	prompt := "AtlasCloud/minimax compatibility: use native tool_calls for the listed service tools. " +
+		"For built-in agent tools that are not listed natively (" + strings.Join(builtins, ", ") +
+		"), emit exactly <tool_call name=\"tool_name\">{...}</tool_call> so the agent runtime can execute them. Do not describe those built-in tool calls in prose instead of emitting the tag."
+	return atlascloudTools(native), prompt
+}
+
+func atlascloudIsMinimaxModel(model string) bool {
+	model = strings.ToLower(model)
+	return strings.Contains(model, "minimax")
+}
+
+func atlascloudShouldRetryMinimaxCompat(err error, compatTools []map[string]any) bool {
+	if len(compatTools) == 0 {
+		return false
+	}
+	var apiErr *atlascloudAPIError
+	return errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusBadRequest
+}
+
+func atlascloudShouldRetryWithoutTools(err error, req map[string]any) bool {
+	if _, ok := req["tools"]; !ok {
+		return false
+	}
+	var apiErr *atlascloudAPIError
+	return errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusBadRequest
+}
+
 func atlascloudTools(input []ai.Tool) []map[string]any {
 	tools := make([]map[string]any, 0, len(input))
 	for _, t := range input {

ai/atlascloud/atlascloud_test.go

@@ -355,6 +355,8 @@ func TestProvider_GenerateExecutesFollowUpToolCall(t *testing.T) {
 			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-1","function":{"name":"conformance_echo","arguments":"{\"value\":\"agent-conformance\"}"}}]}}]}`))
 		case 2:
 			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-2","function":{"name":"delegate","arguments":"{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}"}}]}}]}`))
+		case 3:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"blocked by policy"}}]}`))
 		default:
 			t.Fatalf("unexpected API call %d", len(bodies))
 		}
@@ -406,6 +408,70 @@ func TestProvider_GenerateExecutesFollowUpToolCall(t *testing.T) {
 	}
 }
 
+func TestProvider_GenerateExecutesMultiStepFollowUpToolCalls(t *testing.T) {
+	var bodies []map[string]any
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		bodies = append(bodies, body)
+		w.Header().Set("Content-Type", "application/json")
+		switch len(bodies) {
+		case 1:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-plan","function":{"name":"plan","arguments":"{\"steps\":[{\"task\":\"create tasks\"},{\"task\":\"notify owner\"}]}"}}]}}]}`))
+		case 2:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-add","function":{"name":"task_TaskService_Add","arguments":"{\"title\":\"Design\"}"}}]}}]}`))
+		case 3:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-delegate","function":{"name":"delegate","arguments":"{\"task\":\"notify owner@acme.com\",\"to\":\"comms\"}"}}]}}]}`))
+		case 4:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"done"}}]}`))
+		default:
+			t.Fatalf("unexpected API call %d", len(bodies))
+		}
+	}))
+	defer ts.Close()
+
+	var calls []string
+	p := NewProvider(
+		ai.WithAPIKey("test-key"),
+		ai.WithBaseURL(ts.URL),
+		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
+			calls = append(calls, call.Name)
+			return ai.ToolResult{ID: call.ID, Content: `{"ok":true}`}
+		}),
+	)
+	resp, err := p.Generate(context.Background(), &ai.Request{
+		Prompt: "plan, create tasks, and delegate notification",
+		Tools: []ai.Tool{
+			{Name: "plan", Description: "record a plan", Properties: map[string]any{"steps": map[string]any{"type": "array"}}},
+			{Name: "task_TaskService_Add", Description: "add task", Properties: map[string]any{"title": map[string]any{"type": "string"}}},
+			{Name: "delegate", Description: "delegate work", Properties: map[string]any{"task": map[string]any{"type": "string"}, "to": map[string]any{"type": "string"}}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Generate returned error: %v", err)
+	}
+	wantCalls := []string{"plan", "task_TaskService_Add", "delegate"}
+	if strings.Join(calls, ",") != strings.Join(wantCalls, ",") {
+		t.Fatalf("tool calls = %v, want %v", calls, wantCalls)
+	}
+	if len(resp.ToolCalls) != 3 {
+		t.Fatalf("ToolCalls = %+v, want all multi-step calls", resp.ToolCalls)
+	}
+	if resp.Answer != "done" {
+		t.Fatalf("Answer = %q, want final follow-up reply", resp.Answer)
+	}
+	if len(bodies) != 4 {
+		t.Fatalf("requests = %d, want initial plus three follow-ups", len(bodies))
+	}
+	for i := 1; i < 4; i++ {
+		if _, ok := bodies[i]["tools"].([]any); !ok {
+			t.Fatalf("follow-up request %d did not include tools: %#v", i+1, bodies[i])
+		}
+	}
+}
+
 func TestProvider_GeneratePreservesFollowUpTextToolCallInReply(t *testing.T) {
 	var bodies []map[string]any
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -454,6 +520,120 @@ func TestProvider_GeneratePreservesFollowUpTextToolCallInReply(t *testing.T) {
 	}
 }
 
+func TestProvider_GenerateRetriesMinimaxBuiltInsAsTextTools(t *testing.T) {
+	var bodies []map[string]any
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		bodies = append(bodies, body)
+		w.Header().Set("Content-Type", "application/json")
+		switch len(bodies) {
+		case 1:
+			http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)
+		case 2:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"<tool_call name=\"delegate\">{\"task\":\"summarize\",\"to\":\"blocked-reviewer\"}</tool_call>"}}]}`))
+		default:
+			t.Fatalf("unexpected API call %d", len(bodies))
+		}
+	}))
+	defer ts.Close()
+
+	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL), ai.WithModel("minimaxai/minimax-m3"))
+	resp, err := p.Generate(context.Background(), &ai.Request{
+		Prompt: "plan and delegate",
+		Tools: []ai.Tool{
+			{Name: "task_TaskService_Add", Description: "add task", Properties: map[string]any{"title": map[string]any{"type": "string"}}},
+			{Name: "plan", Description: "record a plan", Properties: map[string]any{"steps": map[string]any{"type": "array"}}},
+			{Name: "request_input", Description: "request input", Properties: map[string]any{"prompt": map[string]any{"type": "string"}}},
+			{Name: "delegate", Description: "delegate work", Properties: map[string]any{"task": map[string]any{"type": "string"}, "to": map[string]any{"type": "string"}}},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Generate returned error: %v", err)
+	}
+	if !strings.Contains(resp.Reply, `<tool_call name="delegate">`) {
+		t.Fatalf("Reply = %q, want text delegate fallback", resp.Reply)
+	}
+	if len(bodies) != 2 {
+		t.Fatalf("requests = %d, want initial plus compat retry", len(bodies))
+	}
+	initialTools := bodies[0]["tools"].([]any)
+	if len(initialTools) != 4 {
+		t.Fatalf("initial tools = %d, want all tools", len(initialTools))
+	}
+	retryTools := bodies[1]["tools"].([]any)
+	if len(retryTools) != 1 {
+		t.Fatalf("retry tools = %d, want only service tools", len(retryTools))
+	}
+	fn := retryTools[0].(map[string]any)["function"].(map[string]any)
+	if fn["name"] != "task_TaskService_Add" {
+		t.Fatalf("retry tool name = %v, want service tool only", fn["name"])
+	}
+	msgs := bodies[1]["messages"].([]any)
+	compat := msgs[len(msgs)-1].(map[string]any)
+	if compat["role"] != "system" || !strings.Contains(compat["content"].(string), `<tool_call name="tool_name">`) {
+		t.Fatalf("compat instruction = %#v", compat)
+	}
+}
+
+func TestProvider_GenerateFollowUpRetriesWithoutToolsOnBadRequest(t *testing.T) {
+	var bodies []map[string]any
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		var body map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			t.Fatalf("decode request: %v", err)
+		}
+		bodies = append(bodies, body)
+		w.Header().Set("Content-Type", "application/json")
+		switch len(bodies) {
+		case 1:
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"","tool_calls":[{"id":"call-1","function":{"name":"conformance_echo","arguments":"{\"value\":\"agent-conformance\"}"}}]}}]}`))
+		case 2:
+			http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)
+		case 3:
+			if _, ok := body["tools"]; ok {
+				t.Fatalf("no-tools retry still included tools: %#v", body["tools"])
+			}
+			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"done"}}]}`))
+		default:
+			t.Fatalf("unexpected API call %d", len(bodies))
+		}
+	}))
+	defer ts.Close()
+
+	var toolCalls int
+	p := NewProvider(
+		ai.WithAPIKey("test-key"),
+		ai.WithBaseURL(ts.URL),
+		ai.WithModel("minimaxai/minimax-m3"),
+		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
+			toolCalls++
+			return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
+		}),
+	)
+	resp, err := p.Generate(context.Background(), &ai.Request{
+		Prompt: "call a tool",
+		Tools:  []ai.Tool{{Name: "conformance_echo", Description: "echo", Properties: map[string]any{"value": map[string]any{"type": "string"}}}},
+	})
+	if err != nil {
+		t.Fatalf("Generate returned error: %v", err)
+	}
+	if resp.Answer != "done" {
+		t.Fatalf("Answer = %q, want done", resp.Answer)
+	}
+	if toolCalls != 1 {
+		t.Fatalf("tool handler calls = %d, want one (no duplicate side effect)", toolCalls)
+	}
+	if len(bodies) != 3 {
+		t.Fatalf("requests = %d, want chat, failed follow-up, no-tools follow-up", len(bodies))
+	}
+	if _, ok := bodies[1]["tools"]; !ok {
+		t.Fatalf("first follow-up did not include tools")
+	}
+}
+
 func TestProvider_GenerateToolCallHTTPErrorIncludesRequestContext(t *testing.T) {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, `{"code":400,"msg":"bad request"}`, http.StatusBadRequest)