Update architect priorities after A2A handoffs

.github/workflows/harness.yml

@@ -75,20 +75,6 @@ jobs:
             -summary-json provider-conformance-summary.json \
             -summary-markdown provider-conformance-summary.md \
             -capabilities-markdown provider-capabilities.md
-      - name: Publish provider conformance summary
-        if: always()
-        run: |
-          if [ -f provider-conformance-summary.md ]; then
-            cat provider-conformance-summary.md >> "$GITHUB_STEP_SUMMARY"
-          fi
-          if [ -f provider-capabilities.md ]; then
-            {
-              echo
-              echo "## Registered provider capabilities"
-              echo
-              cat provider-capabilities.md
-            } >> "$GITHUB_STEP_SUMMARY"
-          fi
       - name: Upload provider conformance summary
         if: always()
         uses: actions/upload-artifact@v4

agent/agent.go

@@ -207,6 +207,17 @@ func (a *agentImpl) Stream(ctx context.Context, message string) (ai.Stream, erro
 	})
 }
 
+// Resume returns the response for a checkpointed agent run. Completed runs are
+// returned from the checkpoint without calling the model or replaying tool
+// calls; failed or in-progress runs continue from the saved input message.
+func Resume(ctx context.Context, ag Agent, runID string) (*Response, error) {
+	a, ok := ag.(*agentImpl)
+	if !ok {
+		return nil, fmt.Errorf("agent resume: unsupported agent implementation %T", ag)
+	}
+	return a.resume(ctx, runID)
+}
+
 // Pending returns checkpointed agent runs that have not completed. It mirrors
 // flow.Pending for startup recovery loops that drain durable agent work.
 func Pending(ctx context.Context, ag Agent) ([]flow.Run, error) {
@@ -289,10 +300,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		run.Status = "paused"
 		run.State.Stage = agentApprovalStep
 		run.State.Data = []byte(message)
-		if a.pause.Tool == toolHumanInput {
-			run.State.Stage = agentInputStep
-			_ = run.State.Set(inputPause{OriginalMessage: message, Prompt: a.pause.Message})
-		}
 		run.Steps[0].Status = "paused"
 		run.Steps[0].Error = a.pause.Message
 		run.Steps[0].Result = a.pause.Tool

agent/builtin.go

@@ -20,9 +20,8 @@ import (
 // the discovered service tools. There is no separate harness or graph:
 // the LLM calls them like any other tool.
 const (
-	toolPlan       = "plan"
-	toolDelegate   = "delegate"
-	toolHumanInput = "request_input"
+	toolPlan     = "plan"
+	toolDelegate = "delegate"
 )
 
 // builtinTools returns the tool definitions exposed to the model in
@@ -42,18 +41,6 @@ func builtinTools() []ai.Tool {
 				},
 			},
 		},
-		{
-			Name:         toolHumanInput,
-			OriginalName: toolHumanInput,
-			Description: "Pause this agent run when you need missing information, a decision, or other human input before you can continue. " +
-				"The run is checkpointed as input-required and can be resumed with the human response without losing completed tool history.",
-			Properties: map[string]any{
-				"prompt": map[string]any{
-					"type":        "string",
-					"description": "The specific question, decision, or instruction needed from the human operator.",
-				},
-			},
-		},
 		{
 			Name:         toolDelegate,
 			OriginalName: toolDelegate,
@@ -91,9 +78,6 @@ func Builtins(opts ...Option) (tools []ai.Tool, handle func(name string, input m
 		case toolPlan:
 			r := a.handlePlan(ai.ToolCall{Name: name, Input: input})
 			return r.Value, r.Content, true
-		case toolHumanInput:
-			r := a.handleHumanInput(ai.ToolCall{Name: name, Input: input})
-			return r.Value, r.Content, true
 		case toolDelegate:
 			r := a.handleDelegate(context.Background(), ai.ToolCall{Name: name, Input: input})
 			return r.Value, r.Content, true
@@ -162,9 +146,6 @@ func (a *agentImpl) baseHandler() ai.ToolHandler {
 				return ai.ToolResult{ID: call.ID, Value: out, Content: out}
 			}
 		}
-		if call.Name == toolHumanInput {
-			return a.handleHumanInput(call)
-		}
 		if call.Name == toolDelegate {
 			return a.handleDelegate(ctx, call)
 		}
@@ -225,11 +206,6 @@ type approvalPause struct {
 	Message string
 }
 
-type inputPause struct {
-	OriginalMessage string `json:"original_message"`
-	Prompt          string `json:"prompt"`
-}
-
 func (a *agentImpl) approveWrap(next ai.ToolHandler) ai.ToolHandler {
 	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 		if a.opts.Approve != nil {
@@ -257,17 +233,6 @@ func (a *agentImpl) handlePlan(call ai.ToolCall) ai.ToolResult {
 	return ai.ToolResult{ID: call.ID, Value: call.Input, Content: string(data)}
 }
 
-// handleHumanInput records that the model needs operator input before it can continue.
-func (a *agentImpl) handleHumanInput(call ai.ToolCall) ai.ToolResult {
-	prompt, _ := call.Input["prompt"].(string)
-	prompt = strings.TrimSpace(prompt)
-	if prompt == "" {
-		prompt = "human input required"
-	}
-	a.pause = &approvalPause{Tool: toolHumanInput, Message: prompt}
-	return refused(call.ID, ai.RefusedApproval, "input-required: "+prompt)
-}
-
 // handleDelegate hands a subtask to another agent. Delegate-first:
 // if 'to' names a registered agent, it is called via RPC. Otherwise an
 // ephemeral sub-agent is created with a fresh, isolated context, asked

agent/builtin_test.go

@@ -11,15 +11,15 @@ import (
 
 func TestBuiltinTools(t *testing.T) {
 	tools := builtinTools()
-	if len(tools) != 3 {
-		t.Fatalf("builtinTools() = %d tools, want 3", len(tools))
+	if len(tools) != 2 {
+		t.Fatalf("builtinTools() = %d tools, want 2", len(tools))
 	}
 	names := map[string]bool{}
 	for _, tl := range tools {
 		names[tl.Name] = true
 	}
-	if !names[toolPlan] || !names[toolDelegate] || !names[toolHumanInput] {
-		t.Errorf("builtin tools = %v, want plan, request_input, and delegate", names)
+	if !names[toolPlan] || !names[toolDelegate] {
+		t.Errorf("builtin tools = %v, want plan and delegate", names)
 	}
 }
 
@@ -109,8 +109,8 @@ func TestBuiltinsAccessor(t *testing.T) {
 		WithRegistry(registry.NewMemoryRegistry()),
 	)
 
-	if len(tools) != 3 {
-		t.Fatalf("Builtins() returned %d tools, want 3", len(tools))
+	if len(tools) != 2 {
+		t.Fatalf("Builtins() returned %d tools, want 2", len(tools))
 	}
 
 	// A name that isn't a built-in falls through (ok == false).

agent/checkpoint.go

@@ -13,7 +13,6 @@ import (
 const (
 	agentAskStep      = "ask"
 	agentApprovalStep = "approval"
-	agentInputStep    = "input-required"
 )
 
 func (a *agentImpl) newCheckpointRun(runID, message, parentRunID string, existing *flow.Run) flow.Run {
@@ -52,17 +51,6 @@ func (a *agentImpl) saveRun(ctx context.Context, run flow.Run) error {
 	return nil
 }
 
-// Resume returns the response for a checkpointed agent run. Completed runs are
-// returned from the checkpoint without calling the model or replaying tool
-// calls; failed or in-progress runs continue from the saved input message.
-func Resume(ctx context.Context, ag Agent, runID string) (*Response, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return nil, fmt.Errorf("agent resume: unsupported agent implementation %T", ag)
-	}
-	return a.resume(ctx, runID)
-}
-
 func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error) {
 	if a.opts.Checkpoint == nil {
 		return nil, fmt.Errorf("agent %s has no checkpoint configured", a.opts.Name)
@@ -75,9 +63,6 @@ func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error)
 		return nil, fmt.Errorf("agent run %s not found", runID)
 	}
 	if run.Status == "paused" {
-		if run.State.Stage == agentInputStep {
-			return nil, fmt.Errorf("agent run %s is input-required; resume with ResumeInput", runID)
-		}
 		run.Status = "running"
 		run.State.Stage = agentAskStep
 	}
@@ -98,51 +83,6 @@ func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error)
 	return a.askLocked(ctx, run.ID, message, parentID, &run)
 }
 
-// ResumeInput resumes a checkpointed agent run that paused via the built-in
-// request_input tool. The supplied input is appended to the original request so
-// the same run can continue with durable checkpoint and completed tool history.
-func ResumeInput(ctx context.Context, ag Agent, runID, input string) (*Response, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return nil, fmt.Errorf("agent resume input: unsupported agent implementation %T", ag)
-	}
-	return a.resumeInput(ctx, runID, input)
-}
-
-func (a *agentImpl) resumeInput(ctx context.Context, runID, input string) (*Response, error) {
-	if a.opts.Checkpoint == nil {
-		return nil, fmt.Errorf("agent %s has no checkpoint configured", a.opts.Name)
-	}
-	run, ok, err := a.opts.Checkpoint.Load(ctx, runID)
-	if err != nil {
-		return nil, err
-	}
-	if !ok {
-		return nil, fmt.Errorf("agent run %s not found", runID)
-	}
-	if run.Status != "paused" || run.State.Stage != agentInputStep {
-		return nil, fmt.Errorf("agent run %s is not waiting for human input", runID)
-	}
-	var p inputPause
-	if err := run.State.Scan(&p); err != nil {
-		return nil, fmt.Errorf("agent run %s input state decode: %w", runID, err)
-	}
-	message := p.OriginalMessage
-	if message == "" {
-		message = string(run.State.Data)
-	}
-	message += "\n\nHuman input: " + input
-	run.Status = "running"
-	run.State.Stage = agentAskStep
-	run.State.Data = []byte(message)
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if a.model == nil {
-		a.setup()
-	}
-	return a.askLocked(ctx, run.ID, message, run.ParentID, &run)
-}
-
 func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {
 	if a.opts.Checkpoint == nil {
 		return nil, nil

agent/checkpoint_test.go

@@ -3,7 +3,6 @@ package agent
 import (
 	"context"
 	"errors"
-	"strings"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -119,64 +118,6 @@ func TestPendingReturnsUnfinishedAgentRuns(t *testing.T) {
 	}
 }
 
-func TestHumanInputPauseResumesSameRunWithInput(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "input-agent")
-	calls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		calls++
-		if calls == 1 {
-			if opts.ToolHandler != nil {
-				opts.ToolHandler(ctx, ai.ToolCall{ID: "input-1", Name: toolHumanInput, Input: map[string]any{"prompt": "Which region should I deploy to?"}})
-			}
-			return &ai.Response{Reply: "waiting"}, nil
-		}
-		if !strings.Contains(req.Prompt, "Human input: us-east-1") {
-			t.Fatalf("resumed prompt = %q, want human input", req.Prompt)
-		}
-		return &ai.Response{Reply: "deploying to us-east-1"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("input-agent"), WithCheckpoint(cp))
-	_, err := a.Ask(ctx, "deploy the service")
-	if err == nil {
-		t.Fatal("Ask succeeded, want input-required pause")
-	}
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 || runs[0].Status != "paused" || runs[0].State.Stage != agentInputStep {
-		t.Fatalf("paused runs = %#v, want one input-required run", runs)
-	}
-	var pause inputPause
-	if err := runs[0].State.Scan(&pause); err != nil {
-		t.Fatalf("Scan pause: %v", err)
-	}
-	if pause.OriginalMessage != "deploy the service" || pause.Prompt != "Which region should I deploy to?" {
-		t.Fatalf("pause = %#v", pause)
-	}
-
-	if _, err := Resume(ctx, a, runs[0].ID); err == nil || !strings.Contains(err.Error(), "ResumeInput") {
-		t.Fatalf("Resume input-required err = %v, want guidance", err)
-	}
-	resp, err := ResumeInput(ctx, a, runs[0].ID, "us-east-1")
-	if err != nil {
-		t.Fatalf("ResumeInput: %v", err)
-	}
-	if resp.RunID != runs[0].ID || resp.Reply != "deploying to us-east-1" {
-		t.Fatalf("response = %#v", resp)
-	}
-	loaded, ok, err := cp.Load(ctx, runs[0].ID)
-	if err != nil || !ok {
-		t.Fatalf("Load resumed run ok=%v err=%v", ok, err)
-	}
-	if loaded.Status != "done" {
-		t.Fatalf("resumed run status = %q, want done", loaded.Status)
-	}
-}
-
 func TestApprovalDenialPausesCheckpointedRunAndResumeContinues(t *testing.T) {
 	ctx := context.Background()
 	cp := flow.StoreCheckpoint(store.NewStore(), "approval-agent")

agent/memory.go

@@ -3,7 +3,6 @@ package agent
 import (
 	"encoding/json"
 	"fmt"
-	"sort"
 	"strings"
 	"sync"
 
@@ -124,31 +123,17 @@ func (m *storeMemory) Recall(query string, limit int) []ai.Message {
 		limit = 5
 	}
 	terms := recallTerms(query)
-	type match struct {
-		msg   ai.Message
-		score int
-		index int
-	}
-	matches := make([]match, 0, len(m.archive))
-	for i := len(m.archive) - 1; i >= 0; i-- {
+	var out []ai.Message
+	for i := len(m.archive) - 1; i >= 0 && len(out) < limit; i-- {
 		msg := m.archive[i]
-		if score := recallScore(msg, terms); score > 0 {
-			matches = append(matches, match{msg: msg, score: score, index: i})
+		text := strings.ToLower(fmt.Sprint(msg.Content))
+		for _, term := range terms {
+			if strings.Contains(text, term) {
+				out = append(out, msg)
+				break
+			}
 		}
 	}
-	sort.SliceStable(matches, func(i, j int) bool {
-		if matches[i].score != matches[j].score {
-			return matches[i].score > matches[j].score
-		}
-		return matches[i].index > matches[j].index
-	})
-	if len(matches) > limit {
-		matches = matches[:limit]
-	}
-	out := make([]ai.Message, 0, len(matches))
-	for _, match := range matches {
-		out = append(out, match.msg)
-	}
 	return out
 }
 
@@ -243,17 +228,6 @@ func compactText(s string, max int) string {
 	return s
 }
 
-func recallScore(msg ai.Message, terms []string) int {
-	text := strings.ToLower(fmt.Sprint(msg.Content))
-	score := 0
-	for _, term := range terms {
-		if strings.Contains(text, term) {
-			score++
-		}
-	}
-	return score
-}
-
 func recallTerms(query string) []string {
 	seen := map[string]bool{}
 	var terms []string

agent/memory_test.go

@@ -62,46 +62,6 @@ func TestWithMemoryUsed(t *testing.T) {
 	}
 }
 
-func TestCompactingMemoryRecallRanksSpecificMatches(t *testing.T) {
-	m := NewCompactingMemory(store.NewMemoryStore(), "agent/rank/history", 3, 1).(MemoryRecall)
-	writer := m.(Memory)
-	writer.Add("user", "alpha budget is 42")
-	writer.Add("assistant", "noted")
-	writer.Add("user", "beta budget is 7")
-	writer.Add("assistant", "noted")
-	writer.Add("user", "alpha owner is sam")
-
-	recalled := m.Recall("alpha budget", 2)
-	if len(recalled) == 0 {
-		t.Fatal("expected recalled messages")
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("top recall = %q, want alpha budget match", got)
-	}
-}
-
-func TestCompactingMemoryArchivePersistsAndReloads(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewCompactingMemory(st, "agent/reload/history", 3, 1)
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta budget is 7")
-	m.Add("assistant", "noted")
-
-	reloaded := NewCompactingMemory(st, "agent/reload/history", 3, 1)
-	recall, ok := reloaded.(MemoryRecall)
-	if !ok {
-		t.Fatal("compacting memory should support recall")
-	}
-	recalled := recall.Recall("alpha budget", 1)
-	if len(recalled) != 1 {
-		t.Fatalf("recalled %d messages, want 1", len(recalled))
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("reloaded recall = %q, want alpha budget", got)
-	}
-}
-
 // A custom tool is offered to the model and dispatched to its handler.
 func TestWithToolExposedAndDispatched(t *testing.T) {
 	var got map[string]any

ai/anthropic/anthropic.go

@@ -77,9 +77,11 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	// Build initial request
 	apiReq := map[string]any{
 		"model":      p.opts.Model,
-		"max_tokens": anthropicMaxTokens(p.opts),
+		"max_tokens": 8192,
 		"system":     req.SystemPrompt,
-		"messages":   threadAnthropicMessages(req),
+		"messages": []map[string]any{
+			{"role": "user", "content": req.Prompt},
+		},
 	}
 
 	if len(anthropicTools) > 0 {
@@ -99,9 +101,10 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 
 	// Tool execution loop: execute tools, send results back, repeat
 	// until the model responds with text only (no more tool calls)
-	messages := append(threadAnthropicMessages(req),
-		map[string]any{"role": "assistant", "content": cleanContent(rawContent)},
-	)
+	messages := []map[string]any{
+		{"role": "user", "content": req.Prompt},
+		{"role": "assistant", "content": cleanContent(rawContent)},
+	}
 
 	pendingCalls := resp.ToolCalls
 
@@ -124,7 +127,7 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 
 		followUpReq := map[string]any{
 			"model":      p.opts.Model,
-			"max_tokens": anthropicMaxTokens(p.opts),
+			"max_tokens": 8192,
 			"system":     req.SystemPrompt,
 			"messages":   messages,
 		}
@@ -267,24 +270,3 @@ func cleanContent(raw any) any {
 	}
 	return cleaned
 }
-
-// threadAnthropicMessages builds the Anthropic messages array from the
-// conversation history (req.Messages) followed by the current prompt. The
-// system prompt is sent separately via the top-level "system" field.
-func threadAnthropicMessages(req *ai.Request) []map[string]any {
-	msgs := make([]map[string]any, 0, len(req.Messages)+1)
-	for _, m := range req.Messages {
-		msgs = append(msgs, map[string]any{"role": m.Role, "content": m.Content})
-	}
-	if req.Prompt != "" {
-		msgs = append(msgs, map[string]any{"role": "user", "content": req.Prompt})
-	}
-	return msgs
-}
-
-func anthropicMaxTokens(o ai.Options) int {
-	if o.MaxTokens > 0 {
-		return o.MaxTokens
-	}
-	return 8192
-}

ai/atlascloud/atlascloud.go

@@ -20,7 +20,6 @@
 package atlascloud
 
 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -92,21 +91,13 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
-	}
-	for _, m := range req.Messages {
-		messages = append(messages, map[string]any{"role": m.Role, "content": m.Content})
-	}
-	if req.Prompt != "" {
-		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
+		{"role": "user", "content": req.Prompt},
 	}
 
 	apiReq := map[string]any{
 		"model":    p.opts.Model,
 		"messages": messages,
 	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
-	}
 
 	if len(tools) > 0 {
 		apiReq["tools"] = tools
@@ -151,111 +142,8 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	return resp, nil
 }
 
-// Stream generates a streaming response from Atlas Cloud's OpenAI-compatible
-// chat completions endpoint, emitting content deltas as they arrive.
 func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	messages := []map[string]any{
-		{"role": "system", "content": req.SystemPrompt},
-	}
-	for _, m := range req.Messages {
-		messages = append(messages, map[string]any{"role": m.Role, "content": m.Content})
-	}
-	if req.Prompt != "" {
-		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
-	}
-	apiReq := map[string]any{
-		"model":          p.opts.Model,
-		"messages":       messages,
-		"stream":         true,
-		"stream_options": map[string]any{"include_usage": true},
-	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
-	}
-	reqBody, err := json.Marshal(apiReq)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal stream request: %w", err)
-	}
-	apiURL := strings.TrimRight(p.opts.BaseURL, "/") + "/v1/chat/completions"
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(reqBody))
-	if err != nil {
-		return nil, fmt.Errorf("failed to create stream request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Accept", "text/event-stream")
-	httpReq.Header.Set("Authorization", "Bearer "+p.opts.APIKey)
-
-	httpResp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, fmt.Errorf("stream API request failed: %w", err)
-	}
-	if httpResp.StatusCode != http.StatusOK {
-		defer httpResp.Body.Close()
-		respBody, _ := io.ReadAll(httpResp.Body)
-		return nil, fmt.Errorf("stream API error (%s): %s", httpResp.Status, string(respBody))
-	}
-	return &atlasStream{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-type atlasStream struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *atlasStream) Recv() (*ai.Response, error) {
-	for s.scanner.Scan() {
-		line := strings.TrimSpace(s.scanner.Text())
-		if line == "" || strings.HasPrefix(line, ":") {
-			continue
-		}
-		if !strings.HasPrefix(line, "data:") {
-			continue
-		}
-		data := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
-		if data == "[DONE]" {
-			return nil, io.EOF
-		}
-		var chunk struct {
-			Choices []struct {
-				Delta struct {
-					Content string `json:"content"`
-				} `json:"delta"`
-			} `json:"choices"`
-			Usage *struct {
-				PromptTokens     int `json:"prompt_tokens"`
-				CompletionTokens int `json:"completion_tokens"`
-				TotalTokens      int `json:"total_tokens"`
-			} `json:"usage"`
-		}
-		if err := json.Unmarshal([]byte(data), &chunk); err != nil {
-			return nil, fmt.Errorf("failed to parse stream chunk: %w", err)
-		}
-		if len(chunk.Choices) > 0 && chunk.Choices[0].Delta.Content != "" {
-			return &ai.Response{Reply: chunk.Choices[0].Delta.Content}, nil
-		}
-		// Final chunk (after include_usage) carries token usage and no content.
-		if chunk.Usage != nil {
-			return &ai.Response{Usage: ai.Usage{
-				InputTokens:  chunk.Usage.PromptTokens,
-				OutputTokens: chunk.Usage.CompletionTokens,
-				TotalTokens:  chunk.Usage.TotalTokens,
-			}}, nil
-		}
-		continue
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *atlasStream) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
+	return nil, fmt.Errorf("%w: atlascloud provider", ai.ErrStreamingUnsupported)
 }
 
 func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {

ai/openai/openai.go

@@ -85,12 +85,7 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	// Build messages
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
-	}
-	for _, m := range req.Messages {
-		messages = append(messages, map[string]any{"role": m.Role, "content": m.Content})
-	}
-	if req.Prompt != "" {
-		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
+		{"role": "user", "content": req.Prompt},
 	}
 
 	// Build initial request
@@ -98,9 +93,6 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 		"model":    p.opts.Model,
 		"messages": messages,
 	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
-	}
 
 	if len(openaiTools) > 0 {
 		apiReq["tools"] = openaiTools
@@ -154,21 +146,12 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
-	}
-	for _, m := range req.Messages {
-		messages = append(messages, map[string]any{"role": m.Role, "content": m.Content})
-	}
-	if req.Prompt != "" {
-		messages = append(messages, map[string]any{"role": "user", "content": req.Prompt})
+		{"role": "user", "content": req.Prompt},
 	}
 	apiReq := map[string]any{
-		"model":          p.opts.Model,
-		"messages":       messages,
-		"stream":         true,
-		"stream_options": map[string]any{"include_usage": true},
-	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
+		"model":    p.opts.Model,
+		"messages": messages,
+		"stream":   true,
 	}
 	reqBody, err := json.Marshal(apiReq)
 	if err != nil {
@@ -220,27 +203,14 @@ func (s *openAIStream) Recv() (*ai.Response, error) {
 					Content string `json:"content"`
 				} `json:"delta"`
 			} `json:"choices"`
-			Usage *struct {
-				PromptTokens     int `json:"prompt_tokens"`
-				CompletionTokens int `json:"completion_tokens"`
-				TotalTokens      int `json:"total_tokens"`
-			} `json:"usage"`
 		}
 		if err := json.Unmarshal([]byte(data), &chunk); err != nil {
 			return nil, fmt.Errorf("failed to parse stream chunk: %w", err)
 		}
-		if len(chunk.Choices) > 0 && chunk.Choices[0].Delta.Content != "" {
-			return &ai.Response{Reply: chunk.Choices[0].Delta.Content}, nil
+		if len(chunk.Choices) == 0 || chunk.Choices[0].Delta.Content == "" {
+			continue
 		}
-		// Final chunk (after include_usage) carries token usage and no content.
-		if chunk.Usage != nil {
-			return &ai.Response{Usage: ai.Usage{
-				InputTokens:  chunk.Usage.PromptTokens,
-				OutputTokens: chunk.Usage.CompletionTokens,
-				TotalTokens:  chunk.Usage.TotalTokens,
-			}}, nil
-		}
-		continue
+		return &ai.Response{Reply: chunk.Choices[0].Delta.Content}, nil
 	}
 	if err := s.scanner.Err(); err != nil {
 		return nil, err

ai/options.go

@@ -16,8 +16,6 @@ type Options struct {
 	BaseURL string
 	// ToolHandler handles tool calls (optional, for automatic tool execution)
 	ToolHandler ToolHandler
-	// MaxTokens caps the length of the response (0 = provider default)
-	MaxTokens int
 }
 
 // GenerateOptions for generate call
@@ -93,11 +91,3 @@ func WithTools(t *Tools) Option {
 		}
 	}
 }
-
-// WithMaxTokens caps the number of tokens in the response. 0 leaves the
-// provider default in place.
-func WithMaxTokens(n int) Option {
-	return func(o *Options) {
-		o.MaxTokens = n
-	}
-}

ai/retry.go

@@ -13,12 +13,6 @@ type StatusCoder interface {
 	StatusCode() int
 }
 
-// RetryAfterCoder is implemented by provider errors that expose a server
-// supplied retry delay, such as HTTP Retry-After on a 429/503 response.
-type RetryAfterCoder interface {
-	RetryAfter() time.Duration
-}
-
 // ErrorKind classifies provider-boundary failures into stable buckets callers
 // can inspect without parsing provider-specific error strings.
 type ErrorKind string
@@ -119,7 +113,16 @@ func GenerateWithRetry(ctx context.Context, m Model, req *Request, policy Genera
 		// Always back off between retries — exponential and capped — so an
 		// opt-in retry can never become a tight loop hammering the provider,
 		// even if Backoff was left at zero.
-		backoff := retryBackoff(err, attempt, policy.Backoff)
+		backoff := policy.Backoff
+		if backoff <= 0 {
+			backoff = 200 * time.Millisecond
+		}
+		if shift := attempt - 1; shift > 0 {
+			backoff <<= shift
+		}
+		if backoff > 30*time.Second {
+			backoff = 30 * time.Second
+		}
 		t := time.NewTimer(backoff)
 		select {
 		case <-ctx.Done():
@@ -133,30 +136,6 @@ func GenerateWithRetry(ctx context.Context, m Model, req *Request, policy Genera
 	return nil, &RetryError{Attempts: policy.MaxAttempts, Kind: ClassifyError(last), Err: last}
 }
 
-func retryBackoff(err error, attempt int, base time.Duration) time.Duration {
-	backoff := base
-	if backoff <= 0 {
-		backoff = 200 * time.Millisecond
-	}
-	if shift := attempt - 1; shift > 0 {
-		backoff <<= shift
-	}
-	if backoff > 30*time.Second {
-		backoff = 30 * time.Second
-	}
-
-	var retryAfter RetryAfterCoder
-	if errors.As(err, &retryAfter) {
-		if delay := retryAfter.RetryAfter(); delay > backoff {
-			backoff = delay
-		}
-	}
-	if backoff > 30*time.Second {
-		return 30 * time.Second
-	}
-	return backoff
-}
-
 // ClassifyError maps provider and context failures to stable operational kinds.
 func ClassifyError(err error) ErrorKind {
 	if err == nil {

ai/retry_test.go

@@ -139,14 +139,6 @@ type statusErr int
 func (e statusErr) Error() string   { return "provider status" }
 func (e statusErr) StatusCode() int { return int(e) }
 
-type retryAfterErr struct {
-	delay time.Duration
-}
-
-func (e retryAfterErr) Error() string             { return "rate limit exceeded" }
-func (e retryAfterErr) StatusCode() int           { return 429 }
-func (e retryAfterErr) RetryAfter() time.Duration { return e.delay }
-
 func TestClassifyErrorDistinguishesOperationalOutcomes(t *testing.T) {
 	tests := []struct {
 		name string
@@ -189,35 +181,3 @@ func TestGenerateWithRetryExposesRetryErrorKind(t *testing.T) {
 		t.Fatalf("retry error does not unwrap provider status: %v", err)
 	}
 }
-
-func TestGenerateWithRetryHonorsRetryAfterWhenLongerThanBackoff(t *testing.T) {
-	attempts := 0
-	model := retryModel{generate: func(context.Context, *Request, ...GenerateOption) (*Response, error) {
-		attempts++
-		if attempts == 1 {
-			return nil, retryAfterErr{delay: 25 * time.Millisecond}
-		}
-		return &Response{Reply: "ok"}, nil
-	}}
-
-	start := time.Now()
-	resp, err := GenerateWithRetry(context.Background(), model, &Request{Prompt: "hi"}, GeneratePolicy{
-		MaxAttempts: 2,
-		Backoff:     time.Millisecond,
-	})
-	if err != nil {
-		t.Fatalf("GenerateWithRetry returned error: %v", err)
-	}
-	if resp.Reply != "ok" {
-		t.Fatalf("reply = %q, want ok", resp.Reply)
-	}
-	if elapsed := time.Since(start); elapsed < 20*time.Millisecond {
-		t.Fatalf("retry delay = %s, want RetryAfter delay to dominate base backoff", elapsed)
-	}
-}
-
-func TestGenerateWithRetryCapsRetryAfter(t *testing.T) {
-	if got := retryBackoff(retryAfterErr{delay: time.Minute}, 1, time.Millisecond); got != 30*time.Second {
-		t.Fatalf("retryBackoff() = %s, want 30s cap", got)
-	}
-}

cmd/micro/cli/deploy/deploy.go

@@ -42,28 +42,14 @@ func Deploy(c *cli.Context) error {
 		return showDeployHelp()
 	}
 
-	target, remotePath := resolveDeployTarget(c, target, cfg)
-
-	return deploySSH(c, target, cfg, remotePath)
-}
-
-func resolveDeployTarget(c *cli.Context, target string, cfg *config.Config) (string, string) {
-	remotePath := c.String("path")
-	if remotePath == "" {
-		remotePath = defaultRemotePath
-	}
-
 	// Check if target is a named target from config
 	if cfg != nil {
 		if dt, ok := cfg.Deploy[target]; ok {
 			target = dt.SSH
-			if dt.Path != "" && !c.IsSet("path") {
-				remotePath = dt.Path
-			}
 		}
 	}
 
-	return target, remotePath
+	return deploySSH(c, target, cfg)
 }
 
 func showDeployHelp() error {
@@ -96,7 +82,7 @@ func showDeployTargets(cfg *config.Config) error {
 	return fmt.Errorf("%s", sb.String())
 }
 
-func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath string) error {
+func deploySSH(c *cli.Context, target string, cfg *config.Config) error {
 	dir := c.Args().Get(1)
 	if dir == "" {
 		dir = "."
@@ -112,6 +98,7 @@ func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath str
 		cfg, _ = config.Load(absDir)
 	}
 
+	remotePath := c.String("path")
 	if remotePath == "" {
 		remotePath = defaultRemotePath
 	}

cmd/micro/cli/deploy/deploy_test.go

@@ -1,120 +0,0 @@
-package deploy
-
-import (
-	"flag"
-	"os"
-	"strings"
-	"testing"
-
-	"github.com/urfave/cli/v2"
-	"go-micro.dev/v6/cmd/micro/run/config"
-)
-
-func newDeployTestContext(t *testing.T, args ...string) *cli.Context {
-	t.Helper()
-	set := flag.NewFlagSet("deploy", flag.ContinueOnError)
-	set.String("path", defaultRemotePath, "")
-	set.String("ssh", "", "")
-	set.String("service", "", "")
-	set.Bool("build", false, "")
-	if err := set.Parse(args); err != nil {
-		t.Fatalf("parse flags: %v", err)
-	}
-	return cli.NewContext(cli.NewApp(), set, nil)
-}
-
-func TestDeployNoTargetExplainsInitAndDeployHandoff(t *testing.T) {
-	err := showDeployHelp()
-	if err == nil {
-		t.Fatal("expected missing target guidance")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		"no deployment target specified",
-		"sudo micro init --server",
-		"micro deploy user@your-server",
-		"deploy prod",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Fatalf("missing %q in guidance:\n%s", want, msg)
-		}
-	}
-}
-
-func TestDeployListsConfiguredTargetsWhenNoTargetProvided(t *testing.T) {
-	err := showDeployTargets(&config.Config{Deploy: map[string]*config.DeployTarget{
-		"prod":    {Name: "prod", SSH: "deploy@prod.example.com"},
-		"staging": {Name: "staging", SSH: "deploy@staging.example.com"},
-	}})
-	if err == nil {
-		t.Fatal("expected configured target guidance")
-	}
-	msg := err.Error()
-	for _, want := range []string{
-		"Available deploy targets:",
-		"prod -> deploy@prod.example.com",
-		"staging -> deploy@staging.example.com",
-		"micro deploy <target>",
-	} {
-		if !strings.Contains(msg, want) {
-			t.Fatalf("missing %q in configured target guidance:\n%s", want, msg)
-		}
-	}
-}
-
-func TestResolveDeployTargetUsesConfigTargetAndPath(t *testing.T) {
-	ctx := newDeployTestContext(t, "prod")
-	cfg := &config.Config{Deploy: map[string]*config.DeployTarget{
-		"prod": {Name: "prod", SSH: "deploy@prod.example.com", Path: "/srv/micro"},
-	}}
-
-	target, remotePath := resolveDeployTarget(ctx, ctx.Args().First(), cfg)
-	if target != "deploy@prod.example.com" {
-		t.Fatalf("target = %q, want configured SSH", target)
-	}
-	if remotePath != "/srv/micro" {
-		t.Fatalf("remotePath = %q, want configured path", remotePath)
-	}
-}
-
-func TestResolveDeployTargetAllowsCLIPathOverride(t *testing.T) {
-	ctx := newDeployTestContext(t, "--path", "/tmp/micro", "prod")
-	cfg := &config.Config{Deploy: map[string]*config.DeployTarget{
-		"prod": {Name: "prod", SSH: "deploy@prod.example.com", Path: "/srv/micro"},
-	}}
-
-	target, remotePath := resolveDeployTarget(ctx, ctx.Args().First(), cfg)
-	if target != "deploy@prod.example.com" {
-		t.Fatalf("target = %q, want configured SSH", target)
-	}
-	if remotePath != "/tmp/micro" {
-		t.Fatalf("remotePath = %q, want CLI override", remotePath)
-	}
-}
-
-func TestDeployConfigParserSupportsDeployTargets(t *testing.T) {
-	dir := t.TempDir()
-	path := dir + "/micro.mu"
-	content := `service api
-    path ./api
-
-deploy prod
-    ssh deploy@prod.example.com
-    path /srv/micro
-`
-	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	cfg, err := config.ParseMu(path)
-	if err != nil {
-		t.Fatalf("parse config: %v", err)
-	}
-	prod := cfg.Deploy["prod"]
-	if prod == nil {
-		t.Fatal("missing prod deploy target")
-	}
-	if prod.SSH != "deploy@prod.example.com" || prod.Path != "/srv/micro" {
-		t.Fatalf("deploy target = %#v", prod)
-	}
-}

cmd/micro/inspect/inspect.go

@@ -1,169 +0,0 @@
-// Package inspect registers the 'micro inspect' CLI command.
-package inspect
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/urfave/cli/v2"
-	goagent "go-micro.dev/v6/agent"
-	"go-micro.dev/v6/cmd"
-	aiflow "go-micro.dev/v6/flow"
-	"go-micro.dev/v6/store"
-)
-
-func init() {
-	cmd.Register(&cli.Command{
-		Name:  "inspect",
-		Usage: "Inspect recent agent and workflow activity",
-		Description: `Inspect is the CLI checkpoint in the local scaffold → run → chat → inspect loop.
-It reads durable local run history, so it works after the agent or flow has stopped.`,
-		Subcommands: []*cli.Command{
-			{
-				Name:      "agent",
-				Usage:     "Show recent recorded runs for an agent",
-				ArgsUsage: "[agent]",
-				Flags:     inspectAgentFlags(),
-				Action:    inspectAgent,
-			},
-			{
-				Name:      "flow",
-				Usage:     "Show durable run history for a flow",
-				ArgsUsage: "[flow]",
-				Flags:     inspectFlowFlags(),
-				Action:    inspectFlow,
-			},
-		},
-	})
-}
-
-func inspectAgentFlags() []cli.Flag {
-	return []cli.Flag{
-		&cli.BoolFlag{Name: "json", Usage: "Print run summaries as JSON for automation"},
-		&cli.StringFlag{Name: "status", Usage: "Only show runs with this status (running, done, error, refused)"},
-		&cli.StringFlag{Name: "trace", Usage: "Only show runs whose trace id matches this full id or prefix"},
-		&cli.IntFlag{Name: "limit", Usage: "Show the most recently updated N runs"},
-	}
-}
-
-func inspectFlowFlags() []cli.Flag {
-	return []cli.Flag{
-		&cli.BoolFlag{Name: "json", Usage: "Print durable run history as JSON for automation"},
-		&cli.BoolFlag{Name: "pending", Usage: "Only show runs that have not completed"},
-		&cli.StringFlag{Name: "status", Usage: "Only show runs with this status (running, done, failed)"},
-		&cli.IntFlag{Name: "limit", Usage: "Show the most recently updated N runs"},
-		&cli.StringFlag{Name: "stage", Usage: "Only show runs currently checkpointed at this stage"},
-	}
-}
-
-func inspectAgent(c *cli.Context) error {
-	name := c.Args().First()
-	if name == "" {
-		return fmt.Errorf("agent name required: micro inspect agent <name>")
-	}
-	opts := goagent.RunListOptions{Status: c.String("status"), TraceID: c.String("trace"), Limit: c.Int("limit")}
-	runs, err := goagent.ListRunSummariesWithOptions(store.DefaultStore, name, opts)
-	if err != nil {
-		return err
-	}
-	return writeAgentInspection(os.Stdout, name, runs, c.Bool("json"))
-}
-
-func writeAgentInspection(w io.Writer, name string, runs []goagent.RunSummary, asJSON bool) error {
-	if asJSON {
-		enc := json.NewEncoder(w)
-		enc.SetIndent("", "  ")
-		return enc.Encode(runs)
-	}
-	if len(runs) == 0 {
-		fmt.Fprintf(w, "  No agent runs recorded for %q. After chatting, try: micro inspect agent %s\n", name, name)
-		return nil
-	}
-	fmt.Fprintf(w, "  Agent %q runs\n", name)
-	for _, run := range runs {
-		fmt.Fprintf(w, "  %s  status=%s  events=%d  last=%s", run.RunID, run.Status, run.Events, run.LastKind)
-		if run.LastError != "" {
-			fmt.Fprintf(w, "  error=%q", run.LastError)
-		}
-		if run.TraceID != "" {
-			fmt.Fprintf(w, "  trace=%s", shortID(run.TraceID))
-		}
-		fmt.Fprintln(w)
-	}
-	return nil
-}
-
-func inspectFlow(c *cli.Context) error {
-	name := c.Args().First()
-	if name == "" {
-		return fmt.Errorf("flow name required: micro inspect flow <name>")
-	}
-	runs, err := aiflow.StoreCheckpoint(nil, name).List(context.Background())
-	if err != nil {
-		return err
-	}
-	runs = filterFlowInspection(runs, c.Bool("pending"), c.String("status"), c.String("stage"), c.Int("limit"))
-	return writeFlowInspection(os.Stdout, name, runs, c.Bool("json"), c.Bool("pending"))
-}
-
-func filterFlowInspection(runs []aiflow.Run, pending bool, status, stage string, limit int) []aiflow.Run {
-	filtered := make([]aiflow.Run, 0, len(runs))
-	for _, run := range runs {
-		if pending && run.Status == "done" {
-			continue
-		}
-		if status != "" && run.Status != status {
-			continue
-		}
-		if stage != "" && run.State.Stage != stage {
-			continue
-		}
-		filtered = append(filtered, run)
-	}
-	if limit > 0 && len(filtered) > limit {
-		return filtered[len(filtered)-limit:]
-	}
-	return filtered
-}
-
-func writeFlowInspection(w io.Writer, name string, runs []aiflow.Run, asJSON, pending bool) error {
-	if asJSON {
-		enc := json.NewEncoder(w)
-		enc.SetIndent("", "  ")
-		return enc.Encode(runs)
-	}
-	if len(runs) == 0 {
-		if pending {
-			fmt.Fprintf(w, "  No pending flow runs recorded for %q.\n", name)
-			return nil
-		}
-		fmt.Fprintf(w, "  No flow runs recorded for %q. After executing a durable flow, try: micro inspect flow %s\n", name, name)
-		return nil
-	}
-	fmt.Fprintf(w, "  Flow %q runs\n", name)
-	for _, run := range runs {
-		stage := run.State.Stage
-		if stage == "" {
-			stage = "-"
-		}
-		fmt.Fprintf(w, "  %s  status=%s  stage=%s  steps=%d", shortID(run.ID), run.Status, stage, len(run.Steps))
-		for _, step := range run.Steps {
-			if step.Error != "" {
-				fmt.Fprintf(w, "  error=%q", step.Error)
-				break
-			}
-		}
-		fmt.Fprintln(w)
-	}
-	return nil
-}
-
-func shortID(id string) string {
-	if len(id) <= 12 {
-		return id
-	}
-	return id[:12]
-}

cmd/micro/inspect/inspect_test.go

@@ -1,64 +0,0 @@
-package inspect
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-	"testing"
-
-	goagent "go-micro.dev/v6/agent"
-	aiflow "go-micro.dev/v6/flow"
-)
-
-func TestWriteAgentInspectionIncludesActionableBreadcrumbs(t *testing.T) {
-	runs := []goagent.RunSummary{{RunID: "run-1", Status: "error", Events: 4, LastKind: "tool", LastError: "boom", TraceID: "1234567890abcdef"}}
-	var out bytes.Buffer
-	if err := writeAgentInspection(&out, "support", runs, false); err != nil {
-		t.Fatal(err)
-	}
-	got := out.String()
-	for _, want := range []string{"Agent \"support\" runs", "run-1", "status=error", "events=4", "last=tool", `error="boom"`, "trace=1234567890ab"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestWriteAgentInspectionEmptyStateNamesInspectCommand(t *testing.T) {
-	var out bytes.Buffer
-	if err := writeAgentInspection(&out, "support", nil, false); err != nil {
-		t.Fatal(err)
-	}
-	if got := out.String(); !strings.Contains(got, "micro inspect agent support") {
-		t.Fatalf("empty state missing next step: %q", got)
-	}
-}
-
-func TestWriteFlowInspectionIncludesFailedStepBreadcrumb(t *testing.T) {
-	runs := []aiflow.Run{{ID: "1234567890abcdef", Status: "failed", State: aiflow.State{Stage: "charge"}, Steps: []aiflow.StepRecord{{Name: "charge", Status: "failed", Error: "card declined"}}}}
-	var out bytes.Buffer
-	if err := writeFlowInspection(&out, "checkout", runs, false, false); err != nil {
-		t.Fatal(err)
-	}
-	got := out.String()
-	for _, want := range []string{"Flow \"checkout\" runs", "1234567890ab", "status=failed", "stage=charge", "steps=1", `error="card declined"`} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestWriteFlowInspectionJSON(t *testing.T) {
-	runs := []aiflow.Run{{ID: "run-1", Flow: "checkout", Status: "done"}}
-	var out bytes.Buffer
-	if err := writeFlowInspection(&out, "checkout", runs, true, false); err != nil {
-		t.Fatal(err)
-	}
-	var got []aiflow.Run
-	if err := json.Unmarshal(out.Bytes(), &got); err != nil {
-		t.Fatalf("invalid JSON: %v\n%s", err, out.String())
-	}
-	if len(got) != 1 || got[0].ID != "run-1" || got[0].Status != "done" {
-		t.Fatalf("decoded runs = %+v", got)
-	}
-}

cmd/micro/main.go

@@ -12,7 +12,6 @@ import (
 	_ "go-micro.dev/v6/cmd/micro/cli/build"
 	_ "go-micro.dev/v6/cmd/micro/cli/deploy"
 	_ "go-micro.dev/v6/cmd/micro/flow"
-	_ "go-micro.dev/v6/cmd/micro/inspect"
 	_ "go-micro.dev/v6/cmd/micro/mcp"
 	_ "go-micro.dev/v6/cmd/micro/resource"
 	_ "go-micro.dev/v6/cmd/micro/run"

cmd/micro/zero_to_hero_cli_test.go

@@ -19,7 +19,7 @@ func TestZeroToHeroCLIBoundaries(t *testing.T) {
 		}
 	}
 
-	for _, want := range []string{"run", "chat", "flow", "inspect"} {
+	for _, want := range []string{"run", "chat", "flow"} {
 		if !commands[want] {
 			t.Fatalf("missing %q command", want)
 		}
@@ -27,7 +27,4 @@ func TestZeroToHeroCLIBoundaries(t *testing.T) {
 	if !subcommands["flow"]["runs"] {
 		t.Fatal("missing inspect boundary: flow runs")
 	}
-	if !subcommands["inspect"]["agent"] || !subcommands["inspect"]["flow"] {
-		t.Fatal("missing inspect boundary: inspect agent/flow")
-	}
 }

examples/agent-human-input/README.md

@@ -1,36 +0,0 @@
-# Agent Human Input Pause/Resume
-
-Agents can pause a durable run when the model needs a human decision before it
-can continue. This keeps the services → agents → workflows lifecycle in one
-runtime: services expose tools, the agent decides it needs operator input, and
-the same checkpointed run resumes once that input arrives.
-
-## Pattern
-
-```go
-cp := flow.StoreCheckpoint(nil, "deploy-agent")
-ag := agent.New(
-    agent.Name("deploy-agent"),
-    agent.WithCheckpoint(cp),
-)
-
-resp, err := ag.Ask(ctx, "Deploy the service")
-if err != nil {
-    // If the model called the built-in request_input tool, the run is saved as
-    // paused/input-required instead of losing state or completing early.
-    pending, _ := agent.Pending(ctx, ag)
-    runID := pending[0].ID
-
-    // Later, after an operator supplies the missing answer, the same run ID
-    // continues with the original prompt, human input, memory, and completed
-    // tool history intact.
-    resp, err = agent.ResumeInput(ctx, ag, runID, "Deploy to us-east-1")
-}
-_ = resp
-```
-
-The model sees a built-in `request_input` tool with a `prompt` argument. When it
-calls that tool, Go Micro persists the run with status `paused` and stage
-`input-required`. Plain `agent.Resume` continues to support completed, failed,
-and approval-paused runs; input-required runs are resumed with
-`agent.ResumeInput` so the human response is explicit.

examples/support/main.go

@@ -212,39 +212,37 @@ func waitFor(reg registry.Registry, names ...string) {
 	}
 }
 
-func runSupport(provider string) error {
+func main() {
+	provider := flag.String("provider", "mock", "LLM provider: mock (default), anthropic, openai, ...")
+	flag.Parse()
+
 	apiKey := ""
-	if provider == "mock" {
+	if *provider == "mock" {
 		ai.Register("mock", newMock)
-	} else if apiKey = providerKey(provider); apiKey == "" {
-		return fmt.Errorf("no API key for provider %q — set MICRO_AI_API_KEY or the provider's key env", provider)
+	} else if apiKey = providerKey(*provider); apiKey == "" {
+		fmt.Printf("no API key for provider %q — set MICRO_AI_API_KEY or the provider's key env\n", *provider)
+		os.Exit(1)
 	}
 
-	fmt.Printf("\n\033[1mSupport desk (provider: %s)\033[0m\n\n", provider)
+	fmt.Printf("\n\033[1mSupport desk (provider: %s)\033[0m\n\n", *provider)
 
 	// Shared in-memory infrastructure so the demo runs in one process.
 	reg := registry.NewMemoryRegistry()
 	br := broker.NewMemoryBroker()
 	if err := br.Connect(); err != nil {
-		return fmt.Errorf("broker connect: %w", err)
+		fmt.Println("broker connect:", err)
+		os.Exit(1)
 	}
 	cl := client.NewClient(client.Registry(reg), client.Selector(selector.NewSelector(selector.Registry(reg))))
 
 	// Services.
 	tickets := new(TicketService)
 	notify := new(NotifyService)
-	var services []service.Service
 	for name, h := range map[string]any{"customers": new(CustomerService), "tickets": tickets, "notify": notify} {
-		svc := service.New(service.Name(name), service.Address("127.0.0.1:0"), service.Registry(reg), service.Client(cl), service.HandleSignal(false))
+		svc := service.New(service.Name(name), service.Registry(reg), service.Client(cl))
 		_ = svc.Handle(h)
-		services = append(services, svc)
 		go svc.Run()
 	}
-	defer func() {
-		for _, svc := range services {
-			_ = svc.Server().Stop()
-		}
-	}()
 
 	// The support agent manages the three services. The approval gate is
 	// the human-in-the-loop: it can read and triage freely, but emailing a
@@ -252,11 +250,10 @@ func runSupport(provider string) error {
 	// it for a person or a policy; here we approve and log.
 	support := agent.New(
 		agent.Name("support"),
-		agent.Address("127.0.0.1:0"),
 		agent.Services("customers", "tickets", "notify"),
 		agent.Prompt("You are a support agent. For each ticket, look up the customer, set an "+
 			"appropriate priority, and reply to them. Escalate billing issues."),
-		agent.Provider(provider), agent.APIKey(apiKey),
+		agent.Provider(*provider), agent.APIKey(apiKey),
 		agent.ApproveTool(func(tool string, input map[string]any) (bool, string) {
 			if strings.Contains(tool, "Send") {
 				fmt.Printf("  \033[33m▣ approval gate\033[0m %s(%v) — approved\n", tool, input["to"])
@@ -278,7 +275,8 @@ func runSupport(provider string) error {
 		flow.Prompt("A new support ticket arrived: {{.Data}}. Handle it."),
 	)
 	if err := intake.Register(reg, br, cl); err != nil {
-		return fmt.Errorf("flow register: %w", err)
+		fmt.Println("flow register:", err)
+		os.Exit(1)
 	}
 	defer intake.Stop()
 
@@ -289,7 +287,8 @@ func runSupport(provider string) error {
 	fmt.Println("\033[1m> event:\033[0m events.ticket.created", string(body))
 	fmt.Println()
 	if err := br.Publish("events.ticket.created", &broker.Message{Body: body}); err != nil {
-		return fmt.Errorf("publish: %w", err)
+		fmt.Println("publish:", err)
+		os.Exit(1)
 	}
 
 	// Wait for the agent to act.
@@ -306,18 +305,7 @@ func runSupport(provider string) error {
 	}
 	if notify.sent >= 1 {
 		fmt.Println("\n\033[32m✓ ticket triaged and the customer was replied to — triggered by an event\033[0m")
-		return nil
-	}
-	fmt.Println("\n\033[31m✗ the agent did not complete the triage\033[0m")
-	return fmt.Errorf("support agent did not complete triage")
-}
-
-func main() {
-	provider := flag.String("provider", "mock", "LLM provider: mock (default), anthropic, openai, ...")
-	flag.Parse()
-
-	if err := runSupport(*provider); err != nil {
-		fmt.Println(err)
-		os.Exit(1)
+	} else {
+		fmt.Println("\n\033[31m✗ the agent did not complete the triage\033[0m")
 	}
 }

examples/support/main_test.go

@@ -1,9 +0,0 @@
-package main
-
-import "testing"
-
-func TestRunSupportMockSmoke(t *testing.T) {
-	if err := runSupport("mock"); err != nil {
-		t.Fatalf("support example failed: %v", err)
-	}
-}

internal/docs/PRIORITIES.md

@@ -19,11 +19,9 @@ redirect the loop; direction always wins.
 items the loop can auto-merge): brand/positioning copy, breaking public-API
 changes, architectural rewrites. Those go to the human.
 
-## Developer experience (ranked)
+## Later (ranked)
 
-1. **Add durable agent run checkpoint and resume** ([#3306](https://github.com/micro/go-micro/issues/3306)) — the CLI inspection foothold has shipped, so the highest-value Next-roadmap seam is making agent loops resumable like flows: long-running work must survive restarts without unsafe replay or hidden state loss before deeper streaming and observability can be trusted.
-2. **Broaden provider-backed AI streaming coverage** ([#3315](https://github.com/micro/go-micro/issues/3315)) — after checkpoint/resume, extend tested `ai.Stream` coverage across remaining providers so `micro chat`, A2A streaming, and long-running agent interactions behave consistently instead of depending on adapter-specific gaps.
-3. **Emit agent RunInfo as OpenTelemetry spans** ([#3316](https://github.com/micro/go-micro/issues/3316)) — once runs are durable and streaming paths are consistent, turn agent run timelines into correlated spans so operators can inspect model calls, tool calls, failures, and run IDs through the same observability surface as services and flows.
+1. **Add agent memory summarization and retrieval** ([#3273](https://github.com/micro/go-micro/issues/3273)) — with A2A resubscribe/input-required handoffs now shipped, the highest-value remaining roadmap gap is durable memory beyond a fixed context buffer: compact older turns/tool results and retrieve relevant prior facts using the existing agent/store primitives so longer-running agents remain coherent without becoming a separate product layer.
 
 _Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
 architecture-review pass._

internal/harness/provider-conformance/README.md

@@ -1,84 +0,0 @@
-# Provider conformance
-
-This harness keeps the services → agents → workflows lifecycle honest across the
-supported AI providers. It runs the same end-to-end scenarios against each
-configured provider and treats missing provider keys as an explicit skip, so the
-suite is safe for local development, forks, and scheduled CI.
-
-## What it exercises
-
-`go run ./internal/harness/provider-conformance` fans out over the harnesses in
-`internal/harness`:
-
-- `universe` — service discovery plus agent tool calls over the real runtime.
-- `agent-flow` — a workflow event that drives an agent to call services.
-- `plan-delegate` — plan persistence plus agent-to-agent delegation and service
-  calls.
-
-The command also emits the registered provider capability matrix so the run shows
-which providers advertise model, image, video, and streaming support.
-
-## Local usage
-
-Run the deterministic path with no secrets:
-
-```sh
-go run ./internal/harness/provider-conformance -providers mock
-```
-
-Run every live provider that has a key in the environment:
-
-```sh
-go run ./internal/harness/provider-conformance \
-  -summary-json provider-conformance-summary.json \
-  -summary-markdown provider-conformance-summary.md \
-  -capabilities-markdown provider-capabilities.md
-```
-
-Provider keys are read from `MICRO_AI_API_KEY` or the provider-specific variable:
-
-| Provider | Secret / environment variable |
-| --- | --- |
-| Anthropic | `ANTHROPIC_API_KEY` |
-| OpenAI | `OPENAI_API_KEY` |
-| Gemini | `GEMINI_API_KEY` |
-| Groq | `GROQ_API_KEY` |
-| Mistral | `MISTRAL_API_KEY` |
-| Together | `TOGETHER_API_KEY` |
-| AtlasCloud | `ATLASCLOUD_API_KEY` |
-
-Use `-require-configured` when you want a selected provider without a key to fail
-instead of skip:
-
-```sh
-go run ./internal/harness/provider-conformance \
-  -providers anthropic,openai \
-  -require-configured
-```
-
-## Scheduled CI behavior
-
-The `Harness (E2E)` workflow runs on pushes and pull requests with deterministic
-mock LLMs. On the daily schedule and manual dispatch it also runs the live
-provider conformance job. That job:
-
-1. reads the provider keys from repository secrets,
-2. skips providers whose secrets are absent,
-3. fails when any configured provider fails a harness, and
-4. uploads JSON and Markdown coverage artifacts for the run.
-
-The job also appends the Markdown summary and capability matrix to the GitHub
-Actions step summary, making configured, skipped, and failed provider coverage
-visible without downloading artifacts.
-
-## Adding a provider
-
-To bring a new provider into scheduled conformance:
-
-1. register its `ai` provider implementation and capability metadata,
-2. add the provider name and key variable to `providerEnv` in `main.go`,
-3. import the provider package in `main.go`,
-4. pass the matching repository secret through `.github/workflows/harness.yml`,
-   and
-5. run `go run ./internal/harness/provider-conformance -providers <name> \
-   -require-configured` with a live key before opening the change.

internal/harness/zero-to-hero-ci/README.md

@@ -8,9 +8,8 @@ scripted so CI can run it on every push without external services or model keys.
 
 1. **Run** — `micro run` remains available as the local development entry point.
 2. **Chat** — `micro chat` remains available as the interactive agent entry point.
-3. **Inspect** — `micro inspect agent <name>` and `micro inspect flow <name>`
-   remain available as the local run-history inspection step, with `micro flow
-   runs` preserving durable workflow history inspection.
+3. **Inspect** — `micro flow runs` remains available for durable workflow run
+   history inspection.
 
 After the CLI boundary smoke checks, the script runs the deterministic harnesses
 that boot real services, agents, workflows, store-backed run history, and A2A