Update architecture priorities

.github/ISSUE_TEMPLATE/bug_report.md

@@ -48,4 +48,4 @@ Add any other context about the problem here.
 - [Troubleshooting Guide](https://github.com/micro/go-micro/tree/master/internal/website/docs/getting-started.md)
 - [Examples](https://github.com/micro/go-micro/tree/master/examples)
 - [API Reference](https://pkg.go.dev/go-micro.dev/v5)
-- [Discord Community](https://discord.gg/G8Gk5j3uXr)
+- [Discord Community](https://discord.gg/WeMU5AGxD)

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +1,5 @@
 blank_issues_enabled: true
 contact_links:
-  - name: 🔒 Report a vulnerability
-    url: https://github.com/micro/go-micro/security/advisories/new
-    about: Privately disclose security vulnerabilities to the maintainers.
   - name: 💖 Sponsor Go Micro
     url: https://github.com/sponsors/asim
     about: Fund ongoing development and see your name or logo on the project.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -39,4 +39,4 @@ Add any other context, code examples, or screenshots about the feature request h
 - [Roadmap](https://github.com/micro/go-micro/blob/master/ROADMAP.md)
 - [Contributing Guide](https://github.com/micro/go-micro/blob/master/CONTRIBUTING.md)
 - [Architecture Docs](https://github.com/micro/go-micro/tree/master/internal/website/docs/architecture.md)
-- [Discord Community](https://discord.gg/G8Gk5j3uXr)
+- [Discord Community](https://discord.gg/WeMU5AGxD)

.github/loop/NORTH_STAR.md

@@ -1,32 +0,0 @@
-# North Star
-
-The direction the loop aligns every increment to. Depth lives in
-[`internal/docs/THESIS.md`](../../internal/docs/THESIS.md); this is the short,
-operative version the planner and builder read each run.
-
-## Mission
-
-Make building an **agent** as easy as building a **service**, on one runtime.
-Go Micro is a holistic agent harness and service framework encapsulating the
-lifecycle of **services → agents → workflows** — pluggable, progressive, and
-AI-native by default.
-
-## Right now — developer adoption
-
-The framework's depth is strong; the **on-ramp** is the gap. Weight the developer
-experience — a walkable first-agent tutorial, discoverable examples, docs
-wayfinding, install friction, debugging, the 0→1 and 0→hero path — **at least as
-highly as internal hardening**. A developer succeeding on their first agent
-matters more right now than another conformance/observability/interop increment.
-Do not let the queue fill entirely with internal depth work.
-
-## Guardrails
-
-- One concern per PR; small and reversible.
-- The gate is green CI (`go build`, `go test`, `golangci-lint`, `make harness`),
-  not human review — keep the suite strong; the loop is only as good as its evaluator.
-- **Off-limits without a human** (surface as notes, never auto-merge): breaking
-  public-API changes, brand/positioning/marketing copy, new dependencies,
-  architectural rewrites, product-default changes with broad behavioral impact.
-- Stay on `claude/*` / `codex/*` branches; base PRs on `master`. See
-  [`CODEX.md`](../../CODEX.md) and [`internal/docs/CONTINUOUS_IMPROVEMENT.md`](../../internal/docs/CONTINUOUS_IMPROVEMENT.md).

.github/loop/PRIORITIES.md

@@ -1,30 +0,0 @@
-# Priorities
-
-The ranked work queue for the autonomous improvement loop. The
-**architecture-review** pass (the *architect*) owns this file: each run it turns
-the [roadmap](../../ROADMAP.md) plus an internal scan (gaps in the
-services → agents → workflows lifecycle, API coherence, drift, tech debt, test and
-DX friction) into a single ordered list — highest-value first — and links each
-item to a tracking issue. The hourly **continuous-improvement** pass works the
-**top item whose issue is still open**. So the architect decides *what*, and the
-increment loop *builds* it.
-
-**Reading / editing.** An item is done when its linked issue closes (the increment
-that builds it adds `Closes #<issue>`). Roadmap phase (Now → Next → Later) is the
-primary ordering; internal findings are interleaved by value, not kept in a
-separate list. The human can reorder this list — or the issues — at any time to
-redirect the loop; direction always wins.
-
-**Off-limits to the loop** (the architect proposes these as notes, never as queue
-items the loop can auto-merge): brand/positioning copy, breaking public-API
-changes, architectural rewrites. Those go to the human.
-
-## Work queue (ranked)
-
-1. **Handle AtlasCloud plan-delegate partial tool calls** ([#4431](https://github.com/micro/go-micro/issues/4431)) — A current live conformance failure can let AtlasCloud/minimax stop at a partial XML-style tool call, so delegation never produces the required task/notify side effects. This is the highest Now-phase risk because plan/delegate is the core services → agents → workflows seam and must fail or recover deterministically across providers.
-2. **Verify first-agent docs wayfinding stays in lockstep** ([#4441](https://github.com/micro/go-micro/issues/4441)) — Developer adoption remains the current goal after the 0→1/0→hero harness landed. Keep README, website guides, examples, and CLI breadcrumbs aligned so the no-secret first-agent path stays discoverable instead of becoming a stale documentation promise.
-3. **Fix AtlasCloud tool streaming capability mismatch** ([#4438](https://github.com/micro/go-micro/issues/4438)) — The provider matrix currently advertises AtlasCloud streaming capability beyond its tool-streaming implementation, causing the live agent streaming conformance path to run an unsupported assertion. Fixing the capability/implementation seam keeps streaming honest without blocking no-secret adoption work.
-4. **Broaden provider streaming conformance** ([#4386](https://github.com/micro/go-micro/issues/4386)) — Once the provider-specific AtlasCloud mismatch is resolved, expand the broader streaming matrix so chat, agent RPC, and A2A streaming regressions are caught across keyed providers while local CI continues to skip cleanly without secrets.
-
-_Seeded by Claude Code from the roadmap + open issues; thereafter maintained by the
-architecture-review pass._

.github/loop/prompts/builder.md

@@ -1,14 +0,0 @@
-<!--
-The BUILDER prompt — go-micro's continuous-improvement increment. Editable
-policy; the workflow prepends the agent @mention and substitutes __ISSUE__
-before posting. Keep __ISSUE__ literal.
--->
-Run one continuous-improvement increment per `internal/docs/CONTINUOUS_IMPROVEMENT.md`, aligned to the North Star in `.github/loop/NORTH_STAR.md` (the services → agents → workflows lifecycle, with developer adoption as the current goal).
-
-PICK THE WORK FROM THE QUEUE: read `.github/loop/PRIORITIES.md` and take the highest-ranked item whose linked issue is still OPEN — that is your task, and its issue number is the one you close. If `PRIORITIES.md` is missing or every listed item's issue is already closed, fall back to the single highest-value roadmap / open-issue / improvement-radar item yourself.
-
-Implement it, and VERIFY `go build ./...`, `go test ./...`, and `golangci-lint run ./...`.
-
-Open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the `codex/` prefix: `git switch -c codex/increment-__ISSUE__`, then `git push -u origin codex/increment-__ISSUE__`, then `gh pr create --base master --label codex --title "<title>" --body "<body; include 'Closes #<the priority issue you built>' so it leaves the queue, and 'Closes #__ISSUE__' for this run's tracker>"`. Finally enable auto-merge so GitHub merges it once CI is green: `gh pr merge --squash --auto --delete-branch`.
-
-One concern per PR. Stay out of breaking public API and brand/positioning copy — surface those as notes for the human instead.

.github/loop/prompts/coherence.md

@@ -1,14 +0,0 @@
-<!--
-The COHERENCE prompt — go-micro's DevRel pass (public-surface coherence +
-CHANGELOG upkeep + changelog blog). Editable policy; the workflow prepends the
-agent @mention and substitutes __ISSUE__ before posting. Keep __ISSUE__ literal.
--->
-Act as DevRel for go-micro. Do these, in order.
-
-COHERENCE AUDIT. Audit the public surface — `README.md`, `internal/website/` (landing `index.html` + `docs/`), and the blog under `internal/website/blog/` — for coherence with the North Star in `.github/loop/NORTH_STAR.md` (an agent harness and service framework; the services → agents → workflows lifecycle). Look for: places where README / website / docs contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recently merged PRs); whether the README is crisp and leads with the harness positioning; and one to three genuinely blog-worthy items from recently shipped work.
-
-CHANGELOG UPKEEP (safe factual task — goes in the auto-merged PR). Keep `CHANGELOG.md` living, in Keep-a-Changelog format with newest content at the top under `## [Unreleased]`. Enumerate PRs merged to master since the last update (`gh pr list --state merged --base master --limit 60 --json number,title,mergedAt,labels`) and add a concise, user-facing entry for each genuine change not yet recorded under the right `### Added` / `### Changed` / `### Fixed` / `### Documentation` subheading — SKIP internal loop/CI/priorities-refresh churn. If a new `vX.Y.Z` tag was cut since the last run (`git fetch --tags --force`), rename `## [Unreleased]` to `## [X.Y.Z] - <Month YYYY>` and open a fresh empty `## [Unreleased]` above it. Do not invent entries.
-
-CHANGELOG BLOG POST (blog voice — do NOT auto-merge). If, and only if, enough user-facing work has accumulated since the last changelog post to be worth reading (roughly a week's worth; not a near-empty post every day), draft a short "What's new in Go Micro" post as the next-numbered file in `internal/website/blog/`, mirroring the latest post's frontmatter and prev-nav, and add an entry at the top of `internal/website/blog/index.html`. Base it strictly on the CHANGELOG.
-
-THEN: (A) post a findings report as a comment on this issue (#__ISSUE__) — what's aligned, what drifted, what you fixed, the CHANGELOG entries added, and whether you drafted a blog post (and why/why not). (B) Open ONE auto-merging PR for the SAFE factual work only — coherence/crispness fixes AND the CHANGELOG update (NOT brand/positioning rewrites, NOT the blog post): `git switch -c codex/coherence-__ISSUE__`, `git push -u origin codex/coherence-__ISSUE__`, `gh pr create --base master --label codex --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. (C) If you drafted a changelog blog post, open it as a SEPARATE PR (`codex/coherence-blog-__ISSUE__`, title prefixed `blog:`) and do NOT enable auto-merge — leave it for the human. Same for any brand/positioning copy. Do not use the make_pr tool.

.github/loop/prompts/planner.md

@@ -1,16 +0,0 @@
-<!--
-The PLANNER prompt — go-micro's "architect / founder lens". Editable policy;
-the workflow prepends the agent @mention and substitutes __ISSUE__ (this run's
-tracking issue) before posting. Keep __ISSUE__ literal.
--->
-Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together, what is in flight and what just merged, what to prioritize next, and what is missing or has drifted.
-
-(1) TRACK STATE — scan recently merged PRs and open `codex` PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work).
-
-(2) ASSESS against the North Star in `.github/loop/NORTH_STAR.md` — lead with its Mission (*make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON: the blog under `internal/website/blog`, the `README`, and the website (read these, don't rely on the North Star alone), then `ROADMAP.md` (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? CURRENT GOAL — developer adoption: weight the on-ramp (walkable first-agent tutorial, discoverable examples, docs wayfinding, install friction, debugging, 0→1 and 0→hero) at least as highly as internal hardening; do not let the queue fill entirely with internal depth work. Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry) and the dev inner loop (scaffold → run → chat → inspect → deploy). Flag drift in either direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog.
-
-(3) MAINTAIN THE QUEUE in `.github/loop/PRIORITIES.md` — a SINGLE ordered list, highest-value first, each item linking a scoped, CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap with no issue, file one: `gh issue create --label codex --label enhancement --title "<scoped task>" --body "<goal, scope, acceptance criteria>"`.
-
-OUTPUT: post a concise assessment as a comment on this issue (#__ISSUE__) — what shipped, what's in flight, the top risks/gaps, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for `.github/loop/PRIORITIES.md`: `git switch -c codex/planner-__ISSUE__`, `git push -u origin codex/planner-__ISSUE__`, `gh pr create --base master --label codex --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. If the queue is already accurate, just close this issue (`gh issue close __ISSUE__`).
-
-Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Open the PR yourself from the shell with `gh`; do not use the make_pr tool (it is a no-op stub).

.github/loop/prompts/security.md

@@ -1,30 +0,0 @@
-<!--
-The SECURITY prompt — go-micro's security audit. Editable policy; the workflow
-prepends the agent @mention and substitutes __ISSUE__ before posting. Keep
-__ISSUE__ literal.
-
-Deliberately conservative: it does NOT auto-merge fixes, and it does NOT publish
-exploit details in public issues (responsible disclosure).
--->
-Act as the security reviewer for go-micro. Audit for real, exploitable vulnerabilities — skip theoretical or lint-style noise.
-
-GO-MICRO ATTACK SURFACE — weight these:
-- **MCP gateway** (`gateway/mcp`) and **A2A gateway** (`gateway/a2a`) — untrusted input from agents/tools: auth/scope enforcement, injection into downstream RPC, SSRF via tool/agent URLs, rate-limit/circuit-breaker bypass, info leak in errors.
-- **x402 payments** (`wrapper/x402`) — payment verification and settlement: signature/mandate validation, replay, budget-reservation races, facilitator auth (CDP bearer) handling, amount/network confusion.
-- **Auth** (`auth/jwt`, `wrapper/auth`) — token validation, algorithm confusion, scope/priority rule bypass, missing checks on endpoints.
-- **AI providers** (`ai/*`) — base-URL and endpoint handling: SSRF via config-controlled `BaseURL`, API keys leaking into logs/errors, TLS verification.
-- **Agent tool loop** (`agent/`) — prompt injection reaching real tool calls, guardrail (`MaxSteps`/`LoopLimit`/`ApproveTool`) bypass, delegate/plan side effects.
-- **Trust boundaries** — `server` RPC handlers, `broker` consumers, `store`/`registry` inputs, `transport` TLS defaults (v6 verifies by default — confirm nothing regressed).
-- **The loop itself** — `.github/workflows/loop-*.yml`: the `CODEX_TRIGGER_TOKEN` PAT must never be echoed/leaked; workflow inputs must not enable script injection.
-- **Dependencies** — run `govulncheck ./...` (install if needed) and inspect `go.mod` for known CVEs.
-
-DEDUPE against open issues first.
-
-HOW TO REPORT:
-- **Known/public dependency CVEs**: file a `security` issue referencing the CVE + module; you MAY open a PR bumping to the patched version. Do NOT enable auto-merge.
-- **Novel, exploitable vulnerabilities in this code** (not yet public): do NOT post an exploit or PoC in a public issue. File a CONCISE `security` + `needs-human` issue naming the class, location (file/function), and impact only — and note it should go through GitHub private vulnerability reporting. Do NOT open a public fix PR that reveals it.
-- **Low-risk hardening**: a normal `security` issue is fine.
-
-NEVER auto-merge a security change. Never weaken a control to make a test pass. Architectural/breaking fixes → `needs-human` with the tradeoff.
-
-Post a summary as a comment on this issue (#__ISSUE__) — findings by severity, what you filed, what needs a human — then close it (`gh issue close __ISSUE__`). If you open a dependency-bump PR: `git switch -c loop/security-__ISSUE__`, `git push -u origin loop/security-__ISSUE__`, `gh pr create --base master --label codex --label security --title "<title>" --body "<summary, Closes #__ISSUE__>"` — then STOP, do NOT run `gh pr merge --auto`. Do not use the make_pr tool.

.github/loop/prompts/triage.md

@@ -1,14 +0,0 @@
-<!--
-The TRIAGE prompt — go-micro's CI-failure feedback path. Editable policy; the
-workflow prepends the agent @mention and substitutes __ISSUE__ (this tracking
-issue) and __RUNURL__ (the failed run) before posting. Keep both literal.
--->
-Triage the failed CI run at __RUNURL__. It may be the linter (Lint), the unit/integration tests (Run Tests), or the provider-conformance harness (Harness (E2E)).
-
-Read the logs and root-cause each distinct failure. DEDUPE against open issues — if a failure matches an existing issue, comment "recurred" there instead of filing a duplicate.
-
-For each genuine, self-contained defect, file a scoped issue (`gh issue create --label codex --label enhancement --title "<scoped fix>" --body "<root cause, where, acceptance criteria>"`) so the increment loop builds it and the next CI/harness run verifies it. A lint or test failure on master is a real regression — file it so it is fixed promptly; do NOT ignore it.
-
-IGNORE only genuine transient flakes — live-model latency, provider outages, rate limits, network timeouts with no code cause (mostly relevant to the harness). Anything needing a breaking or architectural change: file it as `needs-human` and describe it, rather than auto-queuing it as a routine fix.
-
-Close this issue (`gh issue close __ISSUE__`) when triage is done. Open any PR yourself from the shell with `gh`; do not use the make_pr tool.

.github/workflows/architecture-review.yml

@@ -0,0 +1,51 @@
+name: Architecture Review
+
+# Continuous high-altitude oversight of the whole framework and harness — the
+# "founder lens" of the autonomous loop (internal/docs/CONTINUOUS_IMPROVEMENT.md).
+# Where DevRel watches the public story and the increment loop ships code, the
+# architect watches the SYSTEM and runs alongside the builders: it tracks what is
+# in flight and what just merged, keeps the roadmap priorities live, and judges
+# cohesion (harness <-> framework <-> dev UX), missing pieces, and realignment.
+#
+# Its OUTPUT is the ranked queue in internal/docs/PRIORITIES.md plus an assessment
+# — NOT large refactors. Breaking public-API and architectural changes stay with
+# the human (see CONTINUOUS_IMPROVEMENT.md).
+#
+# Runs hourly, offset before the increment loop (:29) so it re-prioritizes and
+# THEN the loop builds the new top of the queue. Opens a fresh issue and
+# dispatches Codex via CODEX_TRIGGER_TOKEN.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "59 * * * *" # hourly at :59, just before the :29 increment run (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: architecture-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open an architecture review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Architecture review #$RUN_NUMBER" \
+            --body "Continuous architecture / harness oversight against the North Star in internal/docs/THESIS.md. Output: a re-ranked internal/docs/PRIORITIES.md (only if it changed) plus an assessment.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (Architect)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as the architect — the founder lens — for go-micro, running continuously alongside the builders. Hold the whole picture: how the harness, the framework, and the developer UX fit together cohesively, what is in flight and what just merged, what to prioritize next on the roadmap, and what is missing or has drifted. Each run: (1) TRACK STATE — scan recently merged PRs and open codex PRs/issues to see what shipped and what is being built right now, so the queue reflects reality (drop done items, don't re-queue in-flight work). (2) ASSESS against the North Star in internal/docs/THESIS.md — lead with its Mission (*the problem we solve: make building an agent as easy as building a service, on one runtime*) and re-derive alignment from the CANON it names (the blog under internal/website/blog, the README, and the website — read these, don't rely on THESIS.md alone), then ROADMAP.md (Now → Next → Later). Judge every priority against the mission: does it make the services → agents → workflows lifecycle simpler, more cohesive, and more operable? Look at coherence and seams across the core packages (agent, ai, flow, gateway/mcp, gateway/a2a, model, server, store, registry), the dev inner loop (scaffold → run → chat → inspect → deploy), missing pieces, duplication/drift, and realignment. Flag drift in EITHER direction: work drifting from the mission, or the North Star/website drifting from the lived story in the blog (which needs re-grounding in the canon). (3) MAINTAIN THE QUEUE in internal/docs/PRIORITIES.md — a SINGLE ordered list, highest-value first, each item linking a scoped CI-verifiable issue (#N); roadmap phase is the primary ordering, internal findings (cohesion gaps, DX friction, missing pieces) interleaved by value. For any prioritized gap that has no issue yet, file one: \`gh issue create --label codex --label enhancement --title \"<scoped task>\" --body \"<goal, scope, acceptance criteria>\"\`. OUTPUT: post a concise assessment as a comment on this issue (#$ISSUE_NUM) — what shipped, what's in flight, the top risks/gaps/missing pieces, and the reasoning behind the ranking. If the ranking actually changed, open ONE PR for PRIORITIES.md: \`git switch -c codex/architect-$ISSUE_NUM\`, \`git push -u origin codex/architect-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, Closes #$ISSUE_NUM>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. If the queue is already accurate and correctly ranked, do NOT open a PR — just close this issue (\`gh issue close $ISSUE_NUM\`). Do NOT make breaking public-API or architectural changes yourself — surface those in the assessment as notes for the human, never as auto-merged changes. Do not use the make_pr tool (it is a no-op stub)."

.github/workflows/continuous-improvement.yml

@@ -0,0 +1,65 @@
+name: Continuous Improvement
+
+# Durable backbone for the autonomous improvement loop
+# (see internal/docs/CONTINUOUS_IMPROVEMENT.md).
+#
+# A Claude Max subscription provides no API key for CI, so the loop is driven by
+# Codex rather than Claude Code: on a cadence this opens a fresh tracking issue and
+# posts an @codex instruction on it, and Codex runs one improvement increment, opens
+# a PR (git push + gh pr create — the make_pr tool is a no-op stub), and enables
+# GitHub auto-merge (gh pr merge --auto) so the PR lands once the required CI checks
+# pass. No separate merge sweep — branch protection + native auto-merge is the gate.
+# (See the per-issue rationale below.)
+#
+# Codex does NOT respond to comments authored by the github-actions bot, so the
+# dispatch is GATED on a CODEX_TRIGGER_TOKEN secret (a PAT for a user account Codex
+# follows). Until that secret is set the workflow runs but no-ops — this avoids
+# piling up @codex comments that Codex silently ignores. The moment the secret is
+# added the loop activates with no further change.
+#
+# Each run opens a FRESH issue and dispatches Codex there, rather than re-commenting
+# on one tracker issue. Codex derives its PR branch name from the triggering issue's
+# context, so repeated dispatches on a single issue all collapse onto one branch name
+# (codex/github-mention-<that-issue-slug>) — the first increment opens a PR, the rest
+# collide on the occupied branch and silently fail to open one. A unique issue per
+# run gives each increment its own branch and a clean PR. The dispatch asks Codex to
+# "Closes #<issue>" so each tracking issue auto-closes when its PR merges.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "29 * * * *" # hourly, off-minute (tune as needed)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: continuous-improvement
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open a fresh increment issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping dispatch."
+            echo "Codex ignores comments from the github-actions bot, so posting now"
+            echo "would only create noise. Add a CODEX_TRIGGER_TOKEN secret (a PAT for"
+            echo "a user account Codex follows) to activate the loop."
+            exit 0
+          fi
+          # A unique issue per run → unique codex/ branch → no collisions.
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "Continuous improvement increment #$RUN_NUMBER" \
+            --body "Autonomous continuous-improvement increment. North Star: internal/docs/THESIS.md; charter: internal/docs/CONTINUOUS_IMPROVEMENT.md. Tracker: #3024.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Run one continuous-improvement increment per internal/docs/CONTINUOUS_IMPROVEMENT.md, aligned to the North Star in internal/docs/THESIS.md (the holistic services → agents → workflows lifecycle). PICK THE WORK FROM THE QUEUE: read internal/docs/PRIORITIES.md and take the highest-ranked item whose linked issue is still OPEN — that is your task, and its issue number is the one you close. (If PRIORITIES.md is missing or every listed item's issue is already closed, fall back to picking the single highest-value roadmap/issue/improvement-radar item yourself.) Implement it, and verify \`go build ./...\`, \`go test ./...\`, and \`golangci-lint run ./...\`. Then open the PR YOURSELF from the shell — do NOT use the make_pr tool (in this environment it only records metadata and never creates a PR). Create a uniquely-named branch under the codex/ prefix and open the PR from it: \`git switch -c codex/increment-$ISSUE_NUM\`, then \`git push -u origin codex/increment-$ISSUE_NUM\`, then \`gh pr create --base master --label codex --title \"<title>\" --body \"<body; include 'Closes #<the priority issue you built>' so it leaves the queue, and 'Closes #$ISSUE_NUM' for this run's tracker>\"\`. Finally enable auto-merge so GitHub merges it once CI is green: \`gh pr merge --squash --auto --delete-branch\`. The gh CLI is installed and authenticated and origin points to $REPO. One concern per PR; stay out of brand/positioning copy and breaking public API."

.github/workflows/devrel-review.yml

@@ -0,0 +1,47 @@
+name: DevRel Review
+
+# Daily higher-altitude coherence pass over the PUBLIC surface — README,
+# website (landing + docs), and blog — part of the autonomous loop
+# (internal/docs/CONTINUOUS_IMPROVEMENT.md). The hourly increment loop ships
+# code; this keeps the story coherent: docs/website aligned, README crisp, and
+# a steady supply of things worth blogging about.
+#
+# Like the increment loop it opens a fresh issue and dispatches Codex via
+# CODEX_TRIGGER_TOKEN (Codex ignores Actions-bot comments). Autonomy boundary:
+# SAFE factual-alignment and crispness fixes auto-merge; brand/positioning copy
+# and blog drafts are surfaced in the report for the human, never auto-merged.
+
+on:
+  workflow_dispatch: {}
+  schedule:
+    - cron: "0 7 * * *" # daily, 07:00 UTC (tunable)
+
+permissions:
+  issues: write
+
+concurrency:
+  group: devrel-review
+  cancel-in-progress: false
+
+jobs:
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Open a DevRel review issue and dispatch Codex
+        env:
+          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
+          HAS_TRIGGER_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
+          REPO: ${{ github.repository }}
+          RUN_NUMBER: ${{ github.run_number }}
+        run: |
+          if [ "$HAS_TRIGGER_TOKEN" != "true" ]; then
+            echo "CODEX_TRIGGER_TOKEN is not set — skipping (Codex ignores Actions-bot comments)."
+            exit 0
+          fi
+          ISSUE_URL=$(gh issue create --repo "$REPO" \
+            --title "DevRel coherence review #$RUN_NUMBER" \
+            --body "Daily DevRel / coherence pass over README, website (landing + docs), and the blog. North Star: internal/docs/THESIS.md.")
+          ISSUE_NUM="${ISSUE_URL##*/}"
+          echo "Opened issue #$ISSUE_NUM — dispatching Codex (DevRel)."
+          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body \
+          "@codex Act as DevRel for go-micro. Audit the PUBLIC surface — \`README.md\`, \`internal/website/\` (landing \`index.html\` + \`docs/\`), and the blog under \`internal/website/blog/\` — for coherence with the North Star in internal/docs/THESIS.md (an agent harness and service framework; the services → agents → workflows lifecycle). Look for: (1) places where README / website / docs contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recent merged PRs / CHANGELOG.md); (2) whether the README is crisp and leads with the harness positioning; (3) one to three genuinely blog-worthy items from recently shipped work. Then do BOTH of these: (A) post a concise findings report as a comment on this issue (#$ISSUE_NUM) — what is aligned, what drifted, what you fixed, and the blog ideas; (B) for SAFE factual-alignment and crispness fixes only (NOT brand/marketing/positioning rewrites), open one PR: \`git switch -c codex/devrel-$ISSUE_NUM\`, \`git push -u origin codex/devrel-$ISSUE_NUM\`, \`gh pr create --base master --label codex --title \"<title>\" --body \"<summary, including 'Closes #$ISSUE_NUM'>\"\`, then \`gh pr merge --squash --auto --delete-branch\`. Leave brand/positioning copy and blog drafts for the human — describe them in the report, do NOT open auto-merging PRs for them. Do not use the make_pr tool (it is a no-op stub). If you touch code, verify go build/test/golangci-lint. Stay out of breaking public-API changes."

.github/workflows/harness.yml

@@ -12,22 +12,8 @@ on:
   pull_request:
     branches: ["**"]
   schedule:
-    - cron: "17 * * * *" # hourly, so real-model conformance keeps pace with the dev/loop velocity
+    - cron: "17 6 * * *" # daily, so the world is exercised even without changes
   workflow_dispatch:
-    inputs:
-      providers:
-        description: "Comma-separated providers for live conformance (default: all supported)"
-        required: false
-        default: "anthropic,openai,gemini,groq,minimax,mistral,together,atlascloud"
-      harnesses:
-        description: "Comma-separated harnesses for live conformance"
-        required: false
-        default: "agent,universe,agent-flow,plan-delegate,a2a-stream-fallback"
-      require_configured:
-        description: "Fail selected live providers that do not have repository secrets"
-        required: false
-        type: boolean
-        default: false
 
 jobs:
   harness:
@@ -41,13 +27,19 @@ jobs:
           cache: true
       - name: Build
         run: go build ./...
-      - name: 0→1 and 0→hero developer-flow harness
-        run: make harness
+      - name: 0→1 scaffold contract
+        run: go test ./cmd/micro/cli/new -run TestZeroToOneContract -count=1
+      - name: Universe end-to-end (asserts; exits non-zero on failure)
+        run: go run ./internal/harness/universe
+      - name: Agent-flow harness
+        run: go run ./internal/harness/agent-flow
+      - name: 0→hero run/chat/inspect reference scenario
+        run: ./internal/harness/zero-to-hero-ci/run.sh
 
   harness-live:
     name: Provider harnesses (live LLM conformance)
     runs-on: ubuntu-latest
-    # Only on the hourly schedule or a manual run — never automatically on
+    # Only on the daily schedule or a manual run — never automatically on
     # every push/PR, so changes don't quietly burn API credits. Trigger it
     # by hand (Actions → Harness → Run workflow) when changing the agent,
     # flow, or AI internals and you want a real-model check.
@@ -58,52 +50,31 @@ jobs:
         with:
           go-version: stable
           cache: true
+      - name: Agent provider conformance matrix
+        env:
+          GO_MICRO_AGENT_CONFORMANCE_LIVE: "1"
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
+          TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
+          ATLASCLOUD_API_KEY: ${{ secrets.ATLASCLOUD_API_KEY }}
+        run: go test ./agent -run TestAgentProviderConformanceMatrix -count=1 -v
       - name: Provider conformance against live models
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
           GROQ_API_KEY: ${{ secrets.GROQ_API_KEY }}
-          MINIMAX_API_KEY: ${{ secrets.MINIMAX_API_KEY }}
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
           TOGETHER_API_KEY: ${{ secrets.TOGETHER_API_KEY }}
           ATLASCLOUD_API_KEY: ${{ secrets.ATLASCLOUD_API_KEY }}
-          # Atlas Cloud's default chat model was failing the agent/tool-use
-          # conformance harnesses; run it against a stronger tool-use model.
-          # Override with an Actions variable ATLASCLOUD_MODEL if the exact
-          # catalog id differs (Atlas uses org/model ids).
-          ATLASCLOUD_MODEL: ${{ vars.ATLASCLOUD_MODEL || 'minimaxai/minimax-m3' }}
         run: |
-          PROVIDERS="${{ github.event.inputs.providers || 'anthropic,openai,gemini,groq,minimax,mistral,together,atlascloud' }}"
-          HARNESSES="${{ github.event.inputs.harnesses || 'agent,universe,agent-flow,plan-delegate,a2a-stream-fallback' }}"
-          REQUIRE_CONFIGURED="${{ github.event.inputs.require_configured || 'false' }}"
-
-          args=(
-            -providers "$PROVIDERS"
-            -harnesses "$HARNESSES"
-            -summary-json provider-conformance-summary.json
-            -summary-markdown provider-conformance-summary.md
+          go run ./internal/harness/provider-conformance \
+            -summary-json provider-conformance-summary.json \
+            -summary-markdown provider-conformance-summary.md \
             -capabilities-markdown provider-capabilities.md
-          )
-          if [ "$REQUIRE_CONFIGURED" = "true" ]; then
-            args+=( -require-configured )
-          fi
-
-          go run ./internal/harness/provider-conformance "${args[@]}"
-      - 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

.github/workflows/loop-builder.yml

@@ -1,60 +0,0 @@
-name: "Loop: Builder"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/builder.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "29 * * * *"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-builder
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch builder
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/builder.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: build increment #$RUN_NUMBER" \
-            --body "Autonomous builder pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching builder."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-coherence.yml

@@ -1,60 +0,0 @@
-name: "Loop: Coherence"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/coherence.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "0 7 * * *"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-coherence
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch coherence
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/coherence.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: coherence review #$RUN_NUMBER" \
-            --body "Autonomous coherence pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching coherence."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-planner.yml

@@ -1,60 +0,0 @@
-name: "Loop: Planner"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/planner.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "59 * * * *"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-planner
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch planner
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/planner.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: planning review #$RUN_NUMBER" \
-            --body "Autonomous planner pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching planner."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-release.yml

@@ -1,97 +0,0 @@
-name: "Loop: Release"
-
-# Generated by `micro loop init`. Cuts the next tag when the default branch has
-# new commits since the latest one, and pushes it with a PAT (CODEX_TRIGGER_TOKEN)
-# so any tag-triggered release workflow fires. The bump reflects what shipped,
-# read from the CHANGELOG [Unreleased] section: new features (Added/Changed) cut
-# a MINOR; fixes/docs only cut a PATCH; breaking changes are skipped so a MAJOR
-# stays a human decision.
-#
-# The tag MUST be pushed with a PAT, not the default GITHUB_TOKEN: a tag pushed
-# by GITHUB_TOKEN does not trigger other workflows (Actions blocks that recursion).
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "0 23 * * *"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: loop-release
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # need full history + all tags
-          # Do NOT persist the default GITHUB_TOKEN as a git credential: it would
-          # be sent on the PAT push below and override it, so the tag push would
-          # authenticate as github-actions[bot] and 403. Letting the PAT in the
-          # push URL be the only credential is the whole point.
-          persist-credentials: false
-      - name: Cut the next patch tag if there are new commits
-        env:
-          RELEASE_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN }}
-          REPO: ${{ github.repository }}
-        run: |
-          if [ -z "$RELEASE_TOKEN" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping."
-            exit 0
-          fi
-          git fetch --tags --force
-
-          LATEST=$(git tag --list 'v*.*.*' --sort=-v:refname | head -1)
-          if [ -z "$LATEST" ]; then
-            echo "no vMAJOR.MINOR.PATCH tag found — aborting so nothing weird gets tagged."
-            exit 1
-          fi
-          echo "latest tag: $LATEST"
-
-          COUNT=$(git rev-list --count "$LATEST"..HEAD)
-          echo "commits since $LATEST: $COUNT"
-          if [ "$COUNT" -eq 0 ]; then
-            echo "no new commits since $LATEST — no release."
-            exit 0
-          fi
-
-          ver="${LATEST#v}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
-          case "$major.$minor.$patch" in
-            [0-9]*.[0-9]*.[0-9]*) ;;
-            *) echo "unexpected tag shape: $LATEST" ; exit 1 ;;
-          esac
-
-          # Choose the bump from what actually shipped, read from the CHANGELOG
-          # [Unreleased] section (kept current by the coherence role):
-          #   new features (### Added / ### Changed) -> MINOR
-          #   fixes/docs only                        -> PATCH
-          #   breaking (### Removed / "(breaking)")  -> skip; a major is a human call
-          UNRELEASED=""
-          if [ -f CHANGELOG.md ]; then
-            UNRELEASED=$(awk '/^## \[Unreleased\]/{f=1; next} /^## \[/{f=0} f' CHANGELOG.md)
-          fi
-          if printf '%s\n' "$UNRELEASED" | grep -qiE '^### Removed|^### Changed \(breaking\)|BREAKING'; then
-            echo "CHANGELOG [Unreleased] contains breaking changes — a major release is a human decision. Skipping."
-            exit 0
-          elif printf '%s\n' "$UNRELEASED" | grep -qE '^### (Added|Changed)'; then
-            NEXT="v${major}.$((minor + 1)).0"
-            KIND="minor (new features)"
-          else
-            NEXT="v${major}.${minor}.$((patch + 1))"
-            KIND="patch (fixes/docs only)"
-          fi
-          echo "cutting: $NEXT — $KIND ($COUNT commits since $LATEST)"
-
-          git config user.name "loop release bot"
-          git config user.email "noreply@users.noreply.github.com"
-          git tag -a "$NEXT" -m "Release $NEXT — automated $KIND ($COUNT commits since $LATEST)"
-          git push "https://x-access-token:${RELEASE_TOKEN}@github.com/${REPO}.git" "$NEXT"
-          echo "Pushed $NEXT."

.github/workflows/loop-security.yml

@@ -1,60 +0,0 @@
-name: "Loop: Security"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/security.md to the agent (@codex).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on CODEX_TRIGGER_TOKEN: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "0 6 * * 1"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-security
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch security
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/security.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: security review #$RUN_NUMBER" \
-            --body "Autonomous security pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching security."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.github/workflows/loop-triage.yml

@@ -1,57 +0,0 @@
-name: "Loop: Triage"
-
-# Generated by `micro loop init`. The feedback path of the evaluator: when a CI
-# workflow (Harness (E2E), Lint, Run Tests) fails on a non-PR run, dispatch the agent
-# (@codex) with the instruction in .github/loop/prompts/triage.md
-# to root-cause the failure and file scoped fix issues back into the queue — so
-# failures become fixes with no human in the middle. Gated on CODEX_TRIGGER_TOKEN.
-
-on:
-  workflow_run:
-    workflows: ["Harness (E2E)", "Lint", "Run Tests"]
-    types: [completed]
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-triage
-  cancel-in-progress: false
-
-jobs:
-  triage:
-    # Only real failures on branch pushes/schedules — not PR-run failures, which
-    # the PR author already sees.
-    if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event != 'pull_request' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch triage
-        env:
-          GH_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN || github.token }}
-          HAS_TOKEN: ${{ secrets.CODEX_TRIGGER_TOKEN != '' }}
-          REPO: ${{ github.repository }}
-          RUN_ID: ${{ github.event.workflow_run.id }}
-          RUN_URL: ${{ github.event.workflow_run.html_url }}
-          WORKFLOW_NAME: ${{ github.event.workflow_run.name }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "CODEX_TRIGGER_TOKEN is not set — skipping."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/triage.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: triage failed run $RUN_ID ($WORKFLOW_NAME)" \
-            --body "The '$WORKFLOW_NAME' workflow failed on a non-PR run: $RUN_URL")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching triage."
-          {
-            echo "@codex"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" -e "s#__RUNURL__#$RUN_URL#g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

.gitignore

@@ -62,7 +62,6 @@ examples/mcp/hello/hello
 /plan-delegate
 /agent-plan-delegate
 /micro-mcp-gateway
-/agent-ollama
 
 # Local Jekyll / Bundler artifacts
 internal/website/.bundle/

CHANGELOG.md

@@ -2,174 +2,8 @@
 
 All notable changes to Go Micro are documented here.
 
-Format follows [Keep a Changelog](https://keepachangelog.com/) and versions
-follow [Semantic Versioning](https://semver.org/), matching the git tags and
-[GitHub releases](https://github.com/micro/go-micro/releases) (`v6.MINOR.PATCH`).
-Releases are cut automatically as the loop merges improvements — a **minor**
-bump when new features land (`### Added`/`### Changed`), a **patch** when it's
-fixes/docs only; major bumps stay a human decision. The `[Unreleased]` section
-below is kept current between tags and rolled into the next version when it ships.
-
-> Earlier `2026.0x` headings are historical calendar-style markers from before
-> v6 tagging; they are kept for continuity and not reused.
-
----
-
-## [Unreleased]
-
-### Added
-- **Provider HTTP retry signals** — provider failures now preserve HTTP status and `Retry-After` details so retry classification and backoff can respond to rate limits and unavailable providers. (`ai/`)
-
-### Fixed
-- **Stream fallback memory** — unsupported streaming attempts no longer leave stale duplicate user turns before fallback paths continue with non-streaming agent calls. (`agent/`)
-- **Function-style text tool calls** — agent fallback parsing now recognizes provider replies that render tools as function-style calls, including nested JSON arguments. (`agent/`)
-- **Plan/delegate notify recovery** — plan-delegate recovery now waits for recovered notify side effects and routes retries through the communications agent that owns the notification. (`internal/harness/`)
-
-### Documentation
-- **First-agent docs wayfinding guard** — the local harness now includes a focused no-network check for first-agent and 0→hero docs links. (`Makefile`, `internal/harness/`)
-
----
-
-## [6.3.18] - July 2026
-
-### Added
-- **StreamAsk close cancellation** — agent streaming calls now cancel promptly when their runner closes, avoiding orphaned stream work. (`agent/`)
-- **Agent resume pending helper** — agent durability now has a focused helper for resuming pending checkpointed runs. (`agent/`)
-- **Agent tool retry tracing** — agent traces now include tool retry attempts for easier debugging of retry/fallback behavior. (`agent/`)
-- **Shared-broker universe harness** — the universe harness now runs against the shared broker path, improving coverage of the same runtime wiring used by services, agents, and workflows. (`internal/harness/`)
-
-### Fixed
-- **Plan/delegate retry idempotency** — agent retries now preserve side-effect and notification dedupe across conformance retry paths, including completion and owner-notification edge cases. (`agent/`, `internal/harness/`)
-- **AtlasCloud text tool calls** — AtlasCloud fallback handling now recovers more text-rendered tool calls from OpenAI-compatible responses. (`ai/atlascloud/`, `agent/`)
-- **OpenAI-compatible text tool calls** — OpenAI-compatible providers now recover text-rendered tool calls more reliably. (`agent/`)
-- **AtlasCloud multi-step follow-ups** — AtlasCloud tool fallback handling now continues multi-step tool follow-up paths more reliably. (`ai/atlascloud/`, `agent/`)
-
-### Documentation
-- **Agent debugging quickcheck** — docs now include a focused quickcheck path for first-agent debugging. (`internal/website/docs/`)
-- **Website first-agent examples map** — website docs now link the maintained examples wayfinding map for the first-agent route. (`internal/website/docs/`)
-- **Examples wayfinding index** — examples docs now provide a central map for first-agent, support, and interop examples. (`examples/`, `internal/website/docs/`)
-
----
-
-## [6.3.17] - July 2026
-
-### Added
-- **First-agent examples CLI wayfinding** — `micro examples` now prints the maintained provider-free first-agent examples in copy/paste order. (`cmd/micro/`)
-- **0→hero CLI entrypoint** — `micro zero-to-hero` now points developers at the maintained no-secret services → agents → workflows harness and runnable examples. (`cmd/micro/`)
-- **First-agent tutorial smoke harness** — the first-agent tutorial path now has smoke coverage to keep the no-secret on-ramp runnable. (`internal/harness/`)
-- **No-secret agent debugging smoke** — the no-secret agent debugging path now has smoke coverage for the first-agent troubleshooting flow. (`internal/harness/`)
-- **Durable checkpoint resume smoke coverage** — durable agent resume after checkpointing now has focused smoke coverage. (`agent/`, `internal/harness/`)
-
-### Fixed
-- **Plan/delegate notify replays** — duplicate and replayed plan-delegate notifications are now idempotent, so resumed runs do not duplicate completed notifications. (`agent/`, `internal/harness/`)
-- **Provider conformance scheduling** — provider conformance workflow dispatches now guard their scheduling path more reliably. (`.github/workflows/`)
-- **Plan/delegate notification completion** — delegated notifications now preserve plan completion state more reliably, including duplicate, paraphrased, and delegated-owner notification paths. (`agent/`, `internal/harness/`)
-- **AtlasCloud tool fallback** — AtlasCloud built-in tool schemas and follow-up tool fallback handling now recover conformance delegate retries more reliably. (`ai/atlascloud/`, `agent/`)
-- **Agent conformance retry completion** — conformance retry prompts and completion handling are more deterministic for delegated agent runs. (`agent/`, `internal/harness/`)
-
-### Documentation
-- **First-agent quickstart numbering** — the first-agent on-ramp numbering is consistent across the README and website docs. (`README.md`, `internal/website/docs/`)
-- **First-agent inspect command** — docs now use the maintained `micro inspect agent <name>` form. (`README.md`, `internal/website/docs/`)
-- **`micro loop` quickstart wayfinding** — docs now surface the loop quickstart from the public docs index and README wayfinding. (`README.md`, `internal/website/docs/`)
-
----
-
-## [6.3.16] - July 2026
-
-### Added
-- **No-secret agent demo CLI** — the CLI now surfaces `micro agent demo`, making the provider-free first-agent path discoverable from the installed binary. (`cmd/micro/`)
-- **First-agent recovery doctor** — first-agent recovery checks now help diagnose install, scaffold, and provider setup issues before the live agent run. (`cmd/micro/`, `internal/website/docs/guides/`)
-
-### Changed
-- **Architecture lifecycle docs** — the architecture guide now leads with the services → agents → workflows lifecycle and the first-agent on-ramp. (`internal/website/docs/architecture.md`)
-- **First-agent on-ramp** — README and website docs now lead new users through install troubleshooting, no-secret demos, the smallest first-agent example, debugging, and the 0→hero reference path in the same order. (`README.md`, `internal/website/docs/`)
-
-### Fixed
-- **Config close idempotency** — config close paths now tolerate repeated closes safely. (`config/`)
-- **OpenTelemetry child span events** — agent traces now preserve child span events more reliably. (`agent/`)
-
-### Documentation
-- **Security reporting** — security docs now route vulnerability reports through GitHub Security Advisories. (`SECURITY.md`, `internal/website/docs/`)
-- **Install troubleshooting** — the first-agent on-ramp now includes clearer install and PATH recovery guidance. (`internal/website/docs/guides/install-troubleshooting.md`)
-
----
-
-## [6.3.15] - July 2026
-
-### Added
-- **Anthropic streaming** — the Anthropic provider now supports Messages SSE streaming and is registered as a streaming-capable provider, with capability docs and parser coverage. (`ai/anthropic/`, `internal/website/docs/guides/`)
-- **AP2 mandate foundation for A2A** — the A2A gateway now has the shared payment-mandate foundation needed for AP2-style agent payment flows. (`gateway/a2a/`)
-- **Smallest first-agent example** — a no-secret, mock-model first-agent example gives the on-ramp a minimal runnable starting point. (`examples/first-agent/`)
-
-### Changed
-- **First-agent CLI next steps** — CLI output now points new users toward the maintained first-agent path after scaffold/run milestones. (`cmd/micro/`)
-
-### Fixed
-- **Plan/delegate completion** — plan-delegate runs now preserve completed steps, guard ordering, require notify-before-completion, and stabilize checkpoint continuation paths. (`agent/`, `internal/harness/`)
-- **Provider text tool calls** — AtlasCloud and weaker-model fallback paths now recover tagged, `Create`-suffixed, mixed text/tool-call, and follow-up tool calls more reliably. (`agent/`, `ai/atlascloud/`)
-- **First-agent broker isolation** — the first-agent harness now isolates broker state more reliably across runs. (`internal/harness/`)
-
-### Documentation
-- **First-agent example path** — docs and website wayfinding now surface the smallest example, no-secret transcript, and 0→hero path together. (`README.md`, `internal/website/docs/`)
-- **Agent operations guidance** — agent debugging docs now include operational failure guidance, inspect hints, and durable resume pointers. (`internal/website/docs/guides/`)
-
----
-
-## [6.3.14] - July 2026
-
-### Added
-- **MiniMax provider** — run agents against MiniMax's `MiniMax-M3` model via its OpenAI-compatible endpoint, with tool calling and streaming; auto-detected from the base URL. (`ai/minimax/`)
-- **`micro loop` security role** — a new opt-in loop role (`--roles …,security`) that periodically audits a repo for vulnerabilities and files `security` issues. It is deliberately conservative: it never auto-merges fixes and never publishes exploit detail in public issues (responsible disclosure), and risky fixes are marked `needs-human`. go-micro now runs it against its own attack surface (MCP/A2A gateways, x402, auth, provider URLs, agent tool loop, deps). (`cmd/micro/loop/`)
-- **Agent run tracing** — agent model streaming and run-event kinds now emit richer trace detail for debugging agent execution. (`agent/`)
-
-### Changed
-- **Agent memory** — streamed agent replies are persisted in conversation memory so later turns can reference streamed responses. (`agent/`)
-
-### Fixed
-- **Plan/delegate completion** — agents now continue unfinished plan steps more reliably, fail checkpointed runs that leave delegated plans unfinished, recover from unknown plan-delegate tool calls, avoid duplicate side effects, and complete timeout paths deterministically. (`agent/`)
-- **AtlasCloud tool calls** — streaming and request fallback handling now recovers tool-call results from provider responses that omit the expected structured fields. (`ai/atlascloud/`)
-- **Agent preflight diagnostics** — provider setup failures now surface more actionable errors before an agent run starts. (`agent/`)
-- **A2A fallback streams** — fallback stream validation is stricter for malformed or incomplete A2A streaming responses. (`gateway/a2a/`)
-- **File-store test isolation** — file-store expiry and table tests are less timing-sensitive and isolate their state more reliably. (`store/file/`)
-
-### Documentation
-- **First-agent debugging path** — docs now include no-secret transcript checkpoints, durable resume examples, and clearer CLI/website wayfinding for first-agent debugging. (`README.md`, `internal/website/docs/`, `examples/agent-durable/`)
-
----
-
-## [6.3.13] - July 2026
-
-### Added
-- **`micro loop`** — scaffold an autonomous improvement loop into any repository: GitHub Actions workflows dispatched to an @mention-driven coding agent, across up to five roles — `planner` (ranked queue), `builder` (top item as a single-concern PR, auto-merged on green CI), `triage` (CI failures → fix issues), and opt-in `coherence` (docs/CHANGELOG alignment) and `release` (daily patch tag). Each dispatch role's instruction lives in an editable `.github/loop/prompts/<role>.md` file — the workflow is the mechanism, the prompt is the policy — so a repo customizes behavior without forking the CLI. `micro loop init --roles …` writes it all; `micro loop verify` checks the wiring. This is the loop that maintains go-micro itself, generalized. (`cmd/micro/loop/`)
-
-### Changed
-- **x402 payments** — settlement now covers CDP facilitator authentication and conformance edge cases. (`wrapper/x402/`)
-
-### Fixed
-- **Plan/delegate harnessing** — side effects and notifications are now idempotent and deterministic across duplicate, alias, order-scoped, and reachability scenarios. (`agent/`, `internal/harness/`)
-
-### Documentation
-- **First-agent on-ramp** — quickstart docs now connect the no-secret first-agent transcript, example map, and 0→hero path. (`README.md`, `internal/website/docs/`)
-- **Ollama provider docs** — the provider surface, capability matrix, and examples now document local and cloud behavior. (`internal/website/docs/`, `examples/agent-ollama/`)
-
----
-
-## [6.3.12] - July 2026
-
-### Added
-- **Ollama provider** — run agents against open-weight models locally (`/api/chat`, NDJSON streaming) or via Ollama Cloud (OpenAI-compatible `/v1/chat/completions`, SSE), auto-detected from the base URL, with tool calling in both modes. Point any agent at a non-default endpoint with the new `agent.BaseURL` / `micro.AgentBaseURL` option. (`ai/ollama/`, `examples/agent-ollama/`)
-- **Retrieval-backed agent memory** — agents can recall relevant prior turns by similarity, not just the recent window, with a summarizer hook that compacts older history so long conversations stay in budget. (`agent/`)
-- **Scheduled flows** — a flow can run an agent (or any step) on a cron-style schedule, with the dispatch traced end to end. (`flow/`)
-- **Flow verification/grader loop** — a workflow can grade its own step output against a rubric and retry until it passes, plus run-trace analysis to surface where a flow spends its time. (`flow/`)
-- **A2A streaming & continuity** — outbound agent streaming flows through the A2A binding (`message/stream`), with `tasks/resubscribe` and `input-required` handoffs for multi-turn interop. (`gateway/a2a/`)
-
-### Changed
-- **Agent tool-call resilience** — opt-in retries around agent tool calls, and a fallback that executes tool calls emitted as text by weaker models so they still make progress. (`agent/`)
-- **Hardened agent durability** — terminal failure statuses are classified and surfaced, and durable resume-after-restart is covered by tests. (`agent/`)
-
-### Documentation
-- **"Your first agent" walkthrough** and a canonical 0-to-hero reference path, lowering the on-ramp from install to a running agent. (`internal/website/docs/`)
-- **Discord** linked prominently across the README, website nav/footer, and docs. (`https://discord.gg/G8Gk5j3uXr`)
+Format follows [Keep a Changelog](https://keepachangelog.com/). Go Micro uses
+calendar-based versions (YYYY.MM) for the AI-native era.
 
 ---
 

CONTRIBUTING.md

@@ -6,17 +6,6 @@ Thank you for your interest in contributing to Go Micro! This document provides
 
 Be respectful, inclusive, and collaborative. We're all here to build great software together.
 
-## How Go Micro is built
-
-Go Micro is developed by an **autonomous improvement loop** — a planner, a
-generator, and a separate evaluator, running as scheduled GitHub Actions with a
-human setting direction. It's the framework's own thesis (an agent operating a
-system) pointed at itself: an agent harness, built by agents. The full process —
-the planner → generator → evaluator pipeline, the correctness-only merge gate, and
-the guardrails — is documented in
-[`internal/docs/CONTINUOUS_IMPROVEMENT.md`](internal/docs/CONTINUOUS_IMPROVEMENT.md).
-Human contributions follow the same gate: green CI, one concern per PR.
-
 ## Getting Started
 
 1. Fork the repository

Makefile

@@ -8,7 +8,7 @@ LDFLAGS = -X $(GIT_IMPORT).BuildDate=$(BUILD_DATE) -X $(GIT_IMPORT).GitCommit=$(
 # GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser-cross:v1.25.7
 GORELEASER_DOCKER_IMAGE = ghcr.io/goreleaser/goreleaser:latest
 
-.PHONY: test test-race test-coverage harness cli-wayfinding docs-wayfinding install-smoke provider-conformance-mock provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker
+.PHONY: test test-race test-coverage harness provider-conformance lint fmt install-tools proto clean help gorelease-dry-run gorelease-dry-run-docker
 
 # Default target
 help:
@@ -18,11 +18,7 @@ help:
 	@echo "  make test-race     - Run tests with race detector"
 	@echo "  make test-coverage - Run tests with coverage"
 	@echo "  make lint          - Run linter"
-	@echo "  make harness       - Run deterministic getting-started and end-to-end harnesses"
-	@echo "  make cli-wayfinding - Verify installed first-agent CLI wayfinding commands"
-	@echo "  make docs-wayfinding - Verify first-agent docs wayfinding links resolve locally"
-	@echo "  make install-smoke - Verify the local install.sh and first-run CLI smoke path"
-	@echo "  make provider-conformance-mock - Run cross-provider harness with deterministic mock provider"
+	@echo "  make harness       - Run deterministic end-to-end harnesses"
 	@echo "  make provider-conformance - Run harnesses against configured live providers"
 	@echo "  make fmt           - Format code"
 	@echo "  make install-tools - Install development tools"
@@ -46,41 +42,12 @@ test-coverage:
 	go tool cover -html=coverage.out -o coverage.html
 	@echo "Coverage report: coverage.html"
 
-# Run the documented getting-started contracts plus the deterministic
-# services → agents → workflows harnesses (mock LLM — no API key).
-# This mirrors the default CI path so local dogfooding catches scaffold,
-# run/chat/inspect, and 0→hero regressions before a PR is opened.
+# Run the end-to-end harnesses (deterministic, mock LLM — no API key).
+# The universe harness exits non-zero on assertion failure.
 harness:
-	$(MAKE) cli-wayfinding
-	go test ./cmd/micro/cli/new -run TestZeroToOne -count=1
-	./internal/harness/zero-to-hero-ci/run.sh
+	go run ./internal/harness/universe
 	go run ./internal/harness/agent-flow
-	$(MAKE) provider-conformance-mock
-
-# Verify the installed CLI keeps the first-agent on-ramp commands discoverable.
-# This guards the no-secret commands README/docs recommend (`micro agent demo`,
-# `micro examples`, and `micro zero-to-hero`) as a CI contract.
-cli-wayfinding:
-	go test ./cmd/micro -run 'TestFirstAgentWalkthroughCLIBoundaries|TestExamplesWayfindingIndexStaysLinked|TestExamplesCommandPointsAtWayfindingIndex|TestZeroToHeroCommandPrintsMaintainedNoSecretPath' -count=1
-	$(MAKE) docs-wayfinding
-	$(MAKE) install-smoke
-
-# Verify the README and website first-agent/0→hero wayfinding links resolve to
-# maintained local docs and examples. This is a focused no-network guard for the
-# developer-adoption on-ramp.
-docs-wayfinding:
-	go test ./internal/harness/zero-to-hero-ci -run 'TestFirstAgentWayfindingDocs|TestFirstAgentWayfindingLinkTargetsResolve' -count=1
-
-# Verify the documented install script and first-run CLI command boundaries without
-# provider keys or network access.
-install-smoke:
-	./internal/harness/install-smoke/run.sh
-
-# Run the shared provider conformance contract with the deterministic mock
-# provider. This is the no-secret path used by CI and local dogfooding to keep
-# provider-facing agent/tool semantics covered on every machine.
-provider-conformance-mock:
-	go run ./internal/harness/provider-conformance -providers mock
+	go run ./internal/harness/plan-delegate # 0→hero: services + agents + flow + plan/delegate
 
 # Run the same harnesses against every configured live provider. Providers
 # without API keys are skipped; configured providers must pass.
@@ -126,3 +93,4 @@ gorelease-dry-run:
 		-w /$(NAME) \
 		$(GORELEASER_DOCKER_IMAGE) \
 		--clean --verbose --skip=publish,validate --snapshot
+

README.md

@@ -1,9 +1,7 @@
-# Go Micro [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v6?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro) [![Discord](https://img.shields.io/badge/Discord-join-5865F2?logo=discord&logoColor=white&style=flat-square)](https://discord.gg/G8Gk5j3uXr)
+# Go Micro [![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-007d9c?logo=go&logoColor=white&style=flat-square)](https://pkg.go.dev/go-micro.dev/v6?tab=doc) [![Go Report Card](https://goreportcard.com/badge/github.com/go-micro/go-micro)](https://goreportcard.com/report/github.com/go-micro/go-micro)
 
 Go Micro is an **agent harness** and service framework for Go.
 
-**Community:** questions, ideas, or just want to build alongside us? [Join the Discord](https://discord.gg/G8Gk5j3uXr).
-
 A harness is the runtime around an agent: the tools it can call, the memory it keeps, the guardrails that bound it, the workflows that trigger it, the services it depends on, and the protocols other agents use to reach it. 
 
 Go Micro gives you the harness as Go code. Build an agent and it gets a model, memory, tools, planning, delegation, guardrails, and service discovery; it is reachable over [MCP](https://modelcontextprotocol.io/) and [A2A](https://a2a-protocol.org). Write services and every endpoint becomes an AI-callable tool. Orchestrate the deterministic parts with durable flows. Agents, services, and flows share one runtime because an agent is a distributed system, and building one is building a service.
@@ -16,7 +14,7 @@ Go Micro gives you the harness as Go code. Build an agent and it gets a model, m
   
 <a href="https://go-micro.dev/blog/8"><img src="https://www.atlascloud.ai/logo.svg" height="26" /></a>
 
-**Want to support Go Micro and see your logo here?** [Become a sponsor](https://discord.gg/G8Gk5j3uXr) — reach out on Discord.
+**Want to support Go Micro and see your logo here?** [Become a sponsor](https://discord.gg/WeMU5AGxD) — reach out on Discord.
 
 ## Commercial Support
 
@@ -25,13 +23,11 @@ Running Go Micro in production, or building on it and want help? Paid **support,
 ## Contents
 
 - [Quick Start](#quick-start)
-  - [First agent on-ramp](#first-agent-on-ramp)
 - [Why an Agent Harness](#why-an-agent-harness)
 - [Writing Services](#writing-services)
 - [Building Agents](#building-agents) — [Plan & Delegate](#plan--delegate), [Pluggable](#batteries-included-pluggable), [Paid tools (x402)](#paid-tools-x402), [A2A](#reachable-by-other-agents-a2a)
 - [Features](#features)
 - [CLI](#cli)
-- [Autonomous improvement loop](#autonomous-improvement-loop)
 - [Multi-Service Projects](#multi-service-projects)
 - [Data Model](#data-model)
 - [AI Providers](#ai-providers)
@@ -48,11 +44,9 @@ Install the CLI:
 curl -fsSL https://go-micro.dev/install.sh | sh
 
 # Or with Go
-go install go-micro.dev/v6/cmd/micro@latest
+go install go-micro.dev/v6/cmd/micro@v6
 ```
 
-If install or `PATH` checks fail, use the [install troubleshooting guide](internal/website/docs/guides/install-troubleshooting.md) before scaffolding your first service.
-
 ### Fastest start — no API key
 
 Scaffold a service, run it, call it:
@@ -70,62 +64,6 @@ curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
   -H 'Content-Type: application/json' -d '{"name":"World"}'
 ```
 
-This install → scaffold → run → call path is covered by no-secret CI harnesses. To
-verify just the local installer and first-run CLI boundaries without network
-access or provider keys, use:
-
-```bash
-make install-smoke
-```
-
-To run the broader local contract (including the [0→hero services → agents → workflows path](internal/website/docs/guides/zero-to-hero.md),
-chat/inspect CLI boundaries, and deploy dry-run), use:
-
-```bash
-make harness
-```
-
-### First agent on-ramp
-
-After install and the first `micro new`/`micro run` smoke check, take the
-walkable agent path in this order:
-
-1. [Install troubleshooting](internal/website/docs/guides/install-troubleshooting.md) — verify the binary installer or `go install`, `PATH`, `micro --version`, and the no-secret smoke path before agent work.
-2. `micro agent demo` — print the provider-free first-agent demo command and next docs steps from the installed CLI.
-3. `micro examples` — print the maintained provider-free runnable examples in copy/paste order.
-4. `micro zero-to-hero` — print the maintained one-command no-secret lifecycle harness and runnable examples.
-5. [Examples wayfinding index](examples/INDEX.md) — choose the smallest no-secret first-agent, maintained [0→hero support reference](examples/support/), and next interop examples from one map.
-6. [Smallest first-agent example](examples/first-agent/) — run one service-backed agent with a mock model and no provider key.
-7. [No-secret first-agent transcript](internal/website/docs/guides/no-secret-first-agent.md) — run the
-   maintained support agent with a mock model and see services → agents → workflows succeed without a key.
-8. [Your First Agent](internal/website/docs/guides/your-first-agent.md) — build a
-   service-backed agent and talk to it with `micro chat`.
-9. [Debugging your agent](internal/website/docs/guides/debugging-agents.md) — use
-   `micro inspect agent <name>`, run history, memory, and provider checks when the first
-   conversation does something unexpected.
-10. [0→hero Reference](internal/website/docs/guides/zero-to-hero.md) — complete the
-   services → agents → workflows loop with scaffold, run, chat, inspect, flow
-   history, and deploy dry-run commands that match the maintained harness.
-
-### Autonomous improvement loop
-
-Want the same services → agents → workflows lifecycle applied to your
-repository? `micro loop` scaffolds the autonomous improvement loop used by Go
-Micro itself: a North Star, ranked issue queue, role prompts, GitHub Actions
-workflows, and verification for CI-gated PRs.
-
-```bash
-micro loop init --roles all
-micro loop verify
-```
-
-Before turning on the schedule, configure a dispatch token such as
-`CODEX_TRIGGER_TOKEN`, protect the default branch with required CI checks
-(`go build ./...`, `go test ./...`, and `golangci-lint run ./...` for this
-repository), and seed `.github/loop/PRIORITIES.md` with one scoped issue per
-increment. See the [`micro loop` quickstart](internal/website/docs/guides/micro-loop.md)
-for the setup checklist and operating model.
-
 ### Generate from a prompt — with an LLM key
 
 Set a provider key, describe what you want, and the AI designs services, writes handlers, compiles, and starts them:
@@ -360,7 +298,7 @@ MCP exposes your services as tools; A2A exposes your agents as agents. See the [
 | MCP gateway | Every endpoint is an AI tool automatically |
 | A2A gateway | Every agent is reachable over the Agent2Agent protocol; cards generated from the registry (`micro a2a`) |
 | Payments (x402) | Opt-in per-call payments for tools via the x402 standard; pluggable facilitator (Base, Solana, …) |
-| 9 LLM providers | Anthropic, OpenAI, Gemini, Groq, Mistral, Together, Atlas Cloud, MiniMax, Ollama (local + cloud) |
+| 7 LLM providers | Anthropic, OpenAI, Gemini, Groq, Mistral, Together, Atlas Cloud |
 | Interactive console | `micro run` includes a chat console for talking to services |
 | Service generation | `micro run --prompt` — describe a system, get running services |
 
@@ -455,10 +393,8 @@ Swap providers with a single import — same interface everywhere:
 | Google Gemini | `gemini-2.5-flash` |
 | Groq | `llama-3.3-70b-versatile` |
 | Mistral | `mistral-large-latest` |
-| Together AI | `meta-llama/Llama-3.3-70B-Instruct-Turbo` |
-| Atlas Cloud | `deepseek-ai/DeepSeek-V3-0324` |
-| MiniMax | `MiniMax-M3` |
-| Ollama | `llama3.2` (local) |
+| Together AI | `Llama-3.3-70B-Instruct-Turbo` |
+| Atlas Cloud | `llama-3.3-70b` |
 
 ```go
 m := ai.New("anthropic", ai.WithAPIKey(key))
@@ -467,14 +403,10 @@ resp, _ := m.Generate(ctx, &ai.Request{Prompt: "hello"})
 
 ## Examples
 
-New to agents? Follow the [first-agent on-ramp](#first-agent-on-ramp), then use the [examples index](examples/README.md) for the full services → agents → workflows map.
-
 - [hello-world](examples/hello-world/) — Basic RPC service
 - [multi-service](examples/multi-service/) — Multiple services in one binary
 - [mcp](examples/mcp/) — MCP integration with AI agents
-- [first-agent](examples/first-agent/) — Smallest provider-free service-backed agent
 - [agent-plan-delegate](examples/agent-plan-delegate/) — Agent planning and multi-agent delegation
-- [agent-durable](examples/agent-durable/) — Checkpoint and resume an agent run without replaying completed tool side effects
 - [grpc-interop](examples/grpc-interop/) — Call go-micro from any gRPC client
 
 See [all examples](examples/README.md).
@@ -483,8 +415,6 @@ See [all examples](examples/README.md).
 
 - [Getting Started](internal/website/docs/getting-started.md)
 - [AI Integration](internal/website/docs/ai-integration.md)
-- [Your First Agent](internal/website/docs/guides/your-first-agent.md)
-- [0→hero Reference](internal/website/docs/guides/zero-to-hero.md)
 - [Agents and Workflows](internal/website/docs/guides/agents-and-workflows.md)
 - [Agent Design](internal/docs/AGENT_DESIGN.md)
 - [Plan & Delegate](internal/website/docs/guides/plan-delegate.md)

ROADMAP.md

@@ -14,9 +14,8 @@ The full, current roadmap lives at **[go-micro.dev/docs/roadmap](https://go-micr
 
 ## Where we are (v6)
 
-Services, agents (`plan`/`delegate`, guardrails, memory, tool middleware,
-checkpoint/resume, and OpenTelemetry run spans), durable flows, the MCP and A2A
-gateways (both directions, including A2A streaming,
+Services, agents (`plan`/`delegate`, guardrails, memory, tool middleware), durable
+flows, the MCP and A2A gateways (both directions, including A2A streaming,
 push notifications, and multi-turn continuation), x402 paid tools, secure by
 default.
 
@@ -40,24 +39,11 @@ default.
   propagation, retry/backoff.
 - **Getting-started contract** — define and CI-verify the 0→1 and 0→hero flows.
 
-## Shipped agent depth
-
-- **Durable agent loop** — opt-in `Checkpoint` support lets agent `Ask` and
-  streaming runs persist, list pending work, and resume without replaying completed
-  tool calls. Human-input pauses resume through explicit input helpers.
-- **Agent observability** — agent `RunInfo` now feeds OpenTelemetry spans/events
-  across runs, model turns, tool calls, retries, delegation lineage, and resume
-  checkpoints.
-
 ## Next — agentic depth
 
+- **Durable agent loop** — resume a long run via `Checkpoint` (flows already do).
 - **Streaming** — broaden provider-backed `ai.Stream` coverage and keep chat/A2A streaming end to end.
-- **Resume operations polish** — keep improving CLI/docs breadcrumbs for finding
-  pending agent runs and deciding whether to call resume, resume-input, or stream
-  resume in production.
-- **Observability hardening** — keep span attributes and run inspection coherent
-  across agents, flows, and gateways as more providers and workflow paths are
-  exercised.
+- **Agent observability** — `RunInfo` → OpenTelemetry spans.
 
 ## Later
 
@@ -80,7 +66,7 @@ hosted service, enterprise tier, or venture funding. See
 ## Contributing & feedback
 
 Pick an item, open an issue to discuss the approach, and submit a PR. Or join the
-[Discord](https://discord.gg/G8Gk5j3uXr). Include tests, run `make test` and
+[Discord](https://discord.gg/WeMU5AGxD). Include tests, run `make test` and
 `make lint`.
 
 ## Version support

SECURITY.md

@@ -17,10 +17,10 @@ We actively support the following versions of go-micro:
 
 ### How to Report
 
-Use GitHub's private security advisory feature:
-https://github.com/micro/go-micro/security/advisories/new
+Send security vulnerability reports to: **security@go-micro.dev**
 
-This keeps vulnerability reports private, ties follow-up to the affected repository, and avoids relying on project email routing.
+Or use GitHub's private security advisory feature:
+https://github.com/micro/go-micro/security/advisories/new
 
 ### What to Include
 
@@ -174,5 +174,6 @@ We currently do not offer a bug bounty program, but we greatly appreciate respon
 
 For security questions that are not vulnerabilities, please:
 - Open a discussion: https://github.com/micro/go-micro/discussions
-- Join Discord: https://discord.gg/G8Gk5j3uXr
+- Join Discord: https://discord.gg/WeMU5AGxD
+- Email: support@go-micro.dev
 

agent/a2a_stream_test.go

@@ -1,102 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/gateway/a2a"
-)
-
-func TestA2AStreamUsesAgentChatPathWithTools(t *testing.T) {
-	var sawTool bool
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("model was not wired with agent tool handler")
-		}
-		result := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "call-1",
-			Name:  "echo",
-			Input: map[string]any{"value": "a2a-stream"},
-		})
-		if !strings.Contains(result.Content, "a2a-stream-ok") {
-			t.Fatalf("tool result = %q, want marker", result.Content)
-		}
-		return &ai.Response{Answer: "streamed " + result.Content}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("stream-agent"), WithTool("echo", "echo text", nil, func(ctx context.Context, input map[string]any) (string, error) {
-		sawTool = true
-		if info, ok := ai.RunInfoFrom(ctx); !ok || info.RunID == "" || info.Agent != "stream-agent" {
-			t.Fatalf("RunInfo = %+v ok=%v, want stream-agent run", info, ok)
-		}
-		if input["value"] != "a2a-stream" {
-			t.Fatalf("tool input = %+v, want a2a-stream", input)
-		}
-		return "a2a-stream-ok", nil
-	}))
-	h := a2a.NewAgentStreamHandler(
-		a2a.Card("stream-agent", "http://example.invalid/stream-agent", "", nil),
-		func(ctx context.Context, text string) (string, error) {
-			resp, err := a.Ask(ctx, text)
-			if err != nil {
-				return "", err
-			}
-			return resp.Reply, nil
-		},
-		a.streamAskAI,
-	)
-
-	body := []byte(`{"jsonrpc":"2.0","id":1,"method":"message/stream","params":{"message":{"role":"user","parts":[{"kind":"text","text":"run stream tool"}],"kind":"message"}}}`)
-	req := httptest.NewRequest(http.MethodPost, "/", bytes.NewReader(body))
-	rr := httptest.NewRecorder()
-	h.ServeHTTP(rr, req)
-
-	if !sawTool {
-		t.Fatal("A2A stream did not execute the agent tool path")
-	}
-	if ct := rr.Result().Header.Get("Content-Type"); !strings.HasPrefix(ct, "text/event-stream") {
-		t.Fatalf("content-type = %q, want text/event-stream", ct)
-	}
-	if !strings.Contains(rr.Body.String(), "a2a-stream-ok") {
-		t.Fatalf("stream body missing tool marker: %s", rr.Body.String())
-	}
-
-	var final struct {
-		Result struct {
-			Status struct {
-				State string `json:"state"`
-			} `json:"status"`
-			Artifacts []struct {
-				Parts []struct {
-					Text string `json:"text"`
-				} `json:"parts"`
-			} `json:"artifacts"`
-		} `json:"result"`
-		Error any `json:"error"`
-	}
-	for _, line := range strings.Split(strings.TrimSpace(rr.Body.String()), "\n") {
-		line = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(line), "data: "))
-		if line == "" {
-			continue
-		}
-		if err := json.Unmarshal([]byte(line), &final); err != nil {
-			t.Fatalf("decode event %q: %v", line, err)
-		}
-	}
-	if final.Error != nil {
-		t.Fatalf("final event error: %+v", final.Error)
-	}
-	if final.Result.Status.State != "completed" {
-		t.Fatalf("final state = %q, want completed", final.Result.Status.State)
-	}
-	if len(final.Result.Artifacts) != 1 || len(final.Result.Artifacts[0].Parts) != 1 || !strings.Contains(final.Result.Artifacts[0].Parts[0].Text, "a2a-stream-ok") {
-		t.Fatalf("final artifacts = %+v, want tool marker", final.Result.Artifacts)
-	}
-}

agent/agent.go

@@ -19,7 +19,6 @@ import (
 	"net/http"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/google/uuid"
 	pb "go-micro.dev/v6/agent/proto"
@@ -34,7 +33,6 @@ import (
 	_ "go-micro.dev/v6/ai/gemini"
 	_ "go-micro.dev/v6/ai/groq"
 	_ "go-micro.dev/v6/ai/mistral"
-	_ "go-micro.dev/v6/ai/ollama"
 	_ "go-micro.dev/v6/ai/openai"
 	_ "go-micro.dev/v6/ai/together"
 )
@@ -99,12 +97,6 @@ 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.
@@ -147,38 +139,19 @@ func (a *agentImpl) String() string {
 }
 
 func (a *agentImpl) setup() {
-	a.setupWithToolHandler(nil)
-}
-
-func (a *agentImpl) setupWithToolHandler(handler ai.ToolHandler) {
 	var modelOpts []ai.Option
 	modelOpts = append(modelOpts, ai.WithAPIKey(a.opts.APIKey))
 	if a.opts.Model != "" {
 		modelOpts = append(modelOpts, ai.WithModel(a.opts.Model))
 	}
-	if a.opts.BaseURL != "" {
-		modelOpts = append(modelOpts, ai.WithBaseURL(a.opts.BaseURL))
-	}
 
-	// Reuse the existing tools instance: its name map is populated by
-	// discoverTools, and rebuilding it here would orphan a base handler that
-	// already captured the old instance (breaking StreamAsk tool resolution).
-	if a.tools == nil {
-		a.tools = ai.NewTools(a.opts.Registry, ai.ToolClient(a.opts.Client))
-	}
-	if handler == nil {
-		handler = a.toolHandler()
-	}
-	modelOpts = append(modelOpts, ai.WithToolHandler(handler))
+	a.tools = ai.NewTools(a.opts.Registry, ai.ToolClient(a.opts.Client))
+	modelOpts = append(modelOpts, ai.WithToolHandler(a.toolHandler()))
 	a.model = ai.New(a.opts.Provider, modelOpts...)
 	if a.model != nil {
 		a.model = a.tracedModel(a.model)
 	}
 
-	if a.mem != nil {
-		return
-	}
-
 	// Memory is pluggable. Use the configured one, otherwise the default
 	// store-backed memory — except ephemeral sub-agents, which keep an
 	// isolated, non-persistent context.
@@ -188,9 +161,7 @@ func (a *agentImpl) setupWithToolHandler(handler ai.ToolHandler) {
 	case a.ephemeral:
 		a.mem = NewInMemory(a.opts.HistoryLimit)
 	case a.opts.MemoryCompaction.MaxMessages > 0:
-		a.mem = NewCompactingMemoryWithOptions(a.stateStore(), "history", a.opts.MemoryCompaction)
-	case a.opts.MemoryRetrievalLimit > 0:
-		a.mem = NewRetrievalMemory(a.stateStore(), "history", a.opts.MemoryRetrievalLimit)
+		a.mem = NewCompactingMemory(a.stateStore(), "history", a.opts.MemoryCompaction.MaxMessages, a.opts.MemoryCompaction.KeepRecent)
 	default:
 		a.mem = NewMemory(a.stateStore(), "history", a.opts.HistoryLimit)
 	}
@@ -227,19 +198,13 @@ func (a *agentImpl) Stream(ctx context.Context, message string) (ai.Stream, erro
 	if err != nil {
 		return nil, fmt.Errorf("discover tools: %w", err)
 	}
-	messages := append([]ai.Message(nil), a.mem.Messages()...)
-	messages = append(messages, ai.Message{Role: "user", Content: message})
-	stream, err := a.model.Stream(ctx, &ai.Request{
+	a.mem.Add("user", message)
+	return a.model.Stream(ctx, &ai.Request{
 		Prompt:       message,
 		SystemPrompt: a.buildPrompt(),
 		Tools:        toolList,
-		Messages:     messages,
+		Messages:     a.mem.Messages(),
 	})
-	if err != nil {
-		return nil, err
-	}
-	a.mem.Add("user", message)
-	return &memoryRecordingStream{stream: stream, memory: a.mem}, nil
 }
 
 // Pending returns checkpointed agent runs that have not completed. It mirrors
@@ -252,31 +217,6 @@ func Pending(ctx context.Context, ag Agent) ([]flow.Run, error) {
 	return a.pending(ctx)
 }
 
-// ResumePending resumes every checkpointed agent run that has not completed
-// yet, in the same oldest-first order returned by Pending.
-//
-// It is a convenience for service startup and recovery loops: after recreating
-// an agent with the same checkpoint store, call ResumePending to drain the
-// durable backlog without listing and resuming each run manually. If any run
-// fails again, ResumePending stops and returns that run id with the error so
-// callers can log, alert, or retry later without hiding the failing run.
-func ResumePending(ctx context.Context, ag Agent) (string, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return "", fmt.Errorf("agent resume pending: unsupported agent implementation %T", ag)
-	}
-	runs, err := a.pending(ctx)
-	if err != nil {
-		return "", err
-	}
-	for _, run := range runs {
-		if _, err := a.resume(ctx, run.ID); err != nil {
-			return run.ID, err
-		}
-	}
-	return "", nil
-}
-
 func (a *agentImpl) ask(ctx context.Context, message, parentRunID string) (*Response, error) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
@@ -285,18 +225,16 @@ func (a *agentImpl) ask(ctx context.Context, message, parentRunID string) (*Resp
 		a.setup()
 	}
 
-	return a.askLocked(ctx, uuid.New().String(), message, parentRunID, nil, true)
+	return a.askLocked(ctx, uuid.New().String(), message, parentRunID, nil)
 }
 
-func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID string, existing *flow.Run, addUserMessage bool) (*Response, error) {
+func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID string, existing *flow.Run) (*Response, error) {
 	toolList, err := a.discoverTools()
 	if err != nil {
 		return nil, fmt.Errorf("discover tools: %w", err)
 	}
 
-	if addUserMessage {
-		a.mem.Add("user", message)
-	}
+	a.mem.Add("user", message)
 	a.steps = 0
 	a.calls = map[string]int{}
 	a.pause = nil
@@ -315,9 +253,6 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		return nil, err
 	}
 	ctx, endRun := a.startRun(ctx, message)
-	if existing != nil {
-		a.recordTimelineEvent(ctx, RunEvent{Time: time.Now(), RunID: runID, ParentID: parentRunID, Agent: a.opts.Name, Kind: "resume", Name: run.State.Stage})
-	}
 	defer func() { endRun(err) }()
 
 	messages := a.mem.Messages()
@@ -330,91 +265,41 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		}
 	}
 
-	// Some providers satisfy a saved plan one outstanding item per turn,
-	// especially when the final item delegates to another agent. Allow enough
-	// continuations for the services → agents → workflows harness to complete
-	// every planned side effect without weakening the final unfinished-plan guard.
-	const maxPlanCompletionTurns = 6
-	var resp *ai.Response
-	for planCompletionTurn := 0; ; planCompletionTurn++ {
-		resp, err = ai.GenerateWithRetry(ctx, a.model, &ai.Request{
-			Prompt:       message,
-			SystemPrompt: a.buildPrompt(),
-			Tools:        toolList,
-			Messages:     messages,
-		}, ai.GeneratePolicy{
-			Timeout:     a.opts.ModelTimeout,
-			MaxAttempts: a.opts.ModelMaxAttempts,
-			Backoff:     a.opts.ModelRetryBackoff,
-		})
-		if err != nil {
-			run.Status = agentRunFailureStatus(err)
-			err = agentOperationalError(err)
-			if a.currentRun != nil {
-				run.Steps = a.currentRun.Steps
-			}
-			if len(run.Steps) == 0 {
-				run.Steps = []flow.StepRecord{{Name: agentAskStep}}
-			}
-			run.Steps[0].Status = run.Status
-			run.Steps[0].Error = err.Error()
-			_ = a.saveRun(ctx, run)
+	resp, err := ai.GenerateWithRetry(ctx, a.model, &ai.Request{
+		Prompt:       message,
+		SystemPrompt: a.buildPrompt(),
+		Tools:        toolList,
+		Messages:     messages,
+	}, ai.GeneratePolicy{
+		Timeout:     a.opts.ModelTimeout,
+		MaxAttempts: a.opts.ModelMaxAttempts,
+		Backoff:     a.opts.ModelRetryBackoff,
+	})
+	if err != nil {
+		run.Status = "failed"
+		run.Steps[0].Status = "failed"
+		run.Steps[0].Error = err.Error()
+		if a.currentRun != nil {
+			run.Steps = a.currentRun.Steps
+		}
+		_ = a.saveRun(ctx, run)
+		return nil, err
+	}
+	if a.pause != nil && a.opts.Checkpoint != nil {
+		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
+		if err := a.saveRun(ctx, run); err != nil {
 			return nil, err
 		}
-		if a.pause != nil && a.opts.Checkpoint != nil {
-			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
-			if err := a.saveRun(ctx, run); err != nil {
-				return nil, err
-			}
-			return nil, fmt.Errorf("agent run %s paused for approval: %s", run.ID, a.pause.Message)
-		}
-
-		if len(resp.ToolCalls) == 0 {
-			if calls, answer, ok := a.executeTextToolCalls(ctx, resp.Reply, toolList); ok {
-				resp.ToolCalls = calls
-				if resp.Answer == "" {
-					resp.Answer = answer
-				}
-				trimmedReply := strings.TrimSpace(resp.Reply)
-				if strings.HasPrefix(trimmedReply, "{") || strings.HasPrefix(trimmedReply, "[") || strings.HasPrefix(trimmedReply, "```") {
-					resp.Reply = ""
-				}
-			}
-		} else if calls, answer, ok := a.executeAdditionalTextToolCalls(ctx, resp.Reply, toolList, resp.ToolCalls); ok {
-			resp.ToolCalls = append(resp.ToolCalls, calls...)
-			if answer != "" {
-				if resp.Answer == "" {
-					resp.Answer = answer
-				} else {
-					resp.Answer += "\n" + answer
-				}
-			}
-		}
-
-		if a.opts.Checkpoint != nil {
-			if unfinished := a.unfinishedPlanSteps(); len(unfinished) > 0 && planCompletionTurn < maxPlanCompletionTurns {
-				if resp.Reply != "" {
-					a.mem.Add("assistant", resp.Reply)
-				}
-				if resp.Answer != "" {
-					a.mem.Add("assistant", resp.Answer)
-				}
-				message = fmt.Sprintf("Continue the same run by calling the required tool(s) for the unfinished plan steps below. Do not repeat completed work, do not provide a final answer yet, and complete at least one unfinished step this turn if a matching tool is available. Unfinished plan steps: %s", strings.Join(unfinished, ", "))
-				a.mem.Add("user", message)
-				messages = a.mem.Messages()
-				continue
-			}
-		}
-		break
+		return nil, fmt.Errorf("agent run %s paused for approval: %s", run.ID, a.pause.Message)
 	}
 
 	if resp.Reply != "" {
@@ -432,35 +317,13 @@ func (a *agentImpl) askLocked(ctx context.Context, runID, message, parentRunID s
 		reply += resp.Answer
 	}
 
-	completedToolCalls := checkpointToolCalls(run.Steps)
-	if a.currentRun != nil {
-		completedToolCalls = checkpointToolCalls(a.currentRun.Steps)
-	}
 	res := &Response{
 		Reply:     reply,
-		ToolCalls: mergeCheckpointToolCalls(completedToolCalls, resp.ToolCalls),
+		ToolCalls: resp.ToolCalls,
 		Agent:     a.opts.Name,
 		RunID:     a.runID,
 		ParentID:  parentRunID,
 	}
-	if a.opts.Checkpoint != nil {
-		if unfinished := a.unfinishedPlanSteps(); len(unfinished) > 0 {
-			err = fmt.Errorf("agent run %s has unfinished plan steps: %s", run.ID, strings.Join(unfinished, ", "))
-			run.Status = "failed"
-			run.State.Stage = agentAskStep
-			run.State.Data = []byte(message)
-			if a.currentRun != nil {
-				run.Steps = a.currentRun.Steps
-			}
-			if len(run.Steps) == 0 {
-				run.Steps = []flow.StepRecord{{Name: agentAskStep}}
-			}
-			run.Steps[0].Status = "failed"
-			run.Steps[0].Error = err.Error()
-			_ = a.saveRun(ctx, run)
-			return nil, err
-		}
-	}
 	run.Status = "done"
 	run.State.Stage = ""
 	if b, marshalErr := json.Marshal(res); marshalErr == nil {
@@ -510,7 +373,7 @@ func (a *agentImpl) Run() error {
 		a.setup()
 	}
 
-	serverOpts := []server.Option{
+	a.server = server.NewServer(
 		server.Name(a.opts.Name),
 		server.Address(a.opts.Address),
 		server.Registry(a.opts.Registry),
@@ -518,11 +381,7 @@ func (a *agentImpl) Run() error {
 			"type":     "agent",
 			"services": strings.Join(a.opts.Services, ","),
 		}),
-	}
-	if a.opts.Broker != nil {
-		serverOpts = append(serverOpts, server.Broker(a.opts.Broker))
-	}
-	a.server = server.NewServer(serverOpts...)
+	)
 
 	_ = pb.RegisterAgentHandler(a.server, a)
 
@@ -542,7 +401,7 @@ func (a *agentImpl) Run() error {
 				return "", err
 			}
 			return resp.Reply, nil
-		}, a.streamAskAI)
+		}, a.Stream)
 		go func() {
 			if err := http.ListenAndServe(a.opts.A2AAddress, handler); err != nil {
 				fmt.Printf("agent %s A2A server: %v\n", a.opts.Name, err)

agent/builtin.go

@@ -2,11 +2,9 @@ package agent
 
 import (
 	"context"
-	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"strings"
-	"time"
 
 	"go-micro.dev/v6/ai"
 	codecBytes "go-micro.dev/v6/codec/bytes"
@@ -27,11 +25,6 @@ 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 {
@@ -120,15 +113,13 @@ func Builtins(opts ...Option) (tools []ai.Tool, handle func(name string, input m
 // prevents runaway recursion).
 func (a *agentImpl) toolHandler() ai.ToolHandler {
 	if a.ephemeral {
-		return a.toolTimeoutWrap(a.tools.Handler())
+		return a.tools.Handler()
 	}
 
 	// Innermost first: base, then guardrails (approve → loop → step →
 	// plan), then developer wrappers outermost. Wrapping reverses order,
 	// so the result runs plan → step → loop → approve → checkpoint → base.
 	h := a.baseHandler()
-	h = a.toolTimeoutWrap(h)
-	h = a.toolRetryWrap(h)
 	h = a.checkpointToolWrap(h)
 	h = a.approveWrap(h)
 	h = a.loopWrap(h)
@@ -157,114 +148,6 @@ func contextWrap(next ai.ToolHandler) ai.ToolHandler {
 	}
 }
 
-// toolTimeoutWrap gives each tool execution its own deadline while preserving
-// caller cancellation. Handlers still execute synchronously; tools that honor
-// context (custom tools, delegate RPC/A2A, and go-micro RPC clients) return
-// promptly with a bounded error result when the deadline expires.
-func (a *agentImpl) toolTimeoutWrap(next ai.ToolHandler) ai.ToolHandler {
-	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		if a.opts.ToolTimeout <= 0 {
-			return next(ctx, call)
-		}
-		toolCtx, cancel := context.WithTimeout(ctx, a.opts.ToolTimeout)
-		defer cancel()
-		return next(toolCtx, call)
-	}
-}
-
-// toolRetryWrap retries transient tool failures with bounded backoff. It is
-// opt-in because tools can have side effects; guardrail refusals and caller
-// cancellation are never retried.
-func (a *agentImpl) toolRetryWrap(next ai.ToolHandler) ai.ToolHandler {
-	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		maxAttempts := a.opts.ToolMaxAttempts
-		if maxAttempts <= 0 {
-			maxAttempts = 1
-		}
-
-		var res ai.ToolResult
-		for attempt := 1; attempt <= maxAttempts; attempt++ {
-			if err := ctx.Err(); err != nil {
-				return errResult(call.ID, err.Error())
-			}
-			res = next(ctx, call)
-			if !retryableToolResult(res) || attempt == maxAttempts || ctx.Err() != nil {
-				return annotateToolAttempts(res, attempt)
-			}
-
-			t := time.NewTimer(toolRetryBackoff(attempt, a.opts.ToolRetryBackoff))
-			select {
-			case <-ctx.Done():
-				if !t.Stop() {
-					<-t.C
-				}
-				return errResult(call.ID, ctx.Err().Error())
-			case <-t.C:
-			}
-		}
-		return annotateToolAttempts(res, maxAttempts)
-	}
-}
-
-func retryableToolResult(res ai.ToolResult) bool {
-	if res.Refused != "" {
-		return false
-	}
-	msg := toolErrorMessage(res)
-	if msg == "" {
-		return false
-	}
-	return ai.IsTransientError(fmt.Errorf("%s", msg))
-}
-
-func toolErrorMessage(res ai.ToolResult) string {
-	if m, ok := res.Value.(map[string]string); ok {
-		return m["error"]
-	}
-	if m, ok := res.Value.(map[string]any); ok {
-		if v, ok := m["error"].(string); ok {
-			return v
-		}
-	}
-	var decoded map[string]string
-	if err := json.Unmarshal([]byte(res.Content), &decoded); err == nil {
-		return decoded["error"]
-	}
-	return ""
-}
-
-func annotateToolAttempts(res ai.ToolResult, attempts int) ai.ToolResult {
-	if attempts <= 1 {
-		return res
-	}
-	res.Attempts = attempts
-	if m, ok := res.Value.(map[string]string); ok {
-		cp := map[string]any{}
-		for k, v := range m {
-			cp[k] = v
-		}
-		cp["attempts"] = attempts
-		res.Value = cp
-		if b, err := json.Marshal(cp); err == nil {
-			res.Content = string(b)
-		}
-	}
-	return res
-}
-
-func toolRetryBackoff(attempt int, base time.Duration) time.Duration {
-	if base <= 0 {
-		base = 200 * time.Millisecond
-	}
-	if shift := attempt - 1; shift > 0 {
-		base <<= shift
-	}
-	if base > 30*time.Second {
-		return 30 * time.Second
-	}
-	return base
-}
-
 // baseHandler executes a tool call: a developer custom tool, the built-in
 // delegate, or an RPC to the service. It is the innermost handler.
 func (a *agentImpl) baseHandler() ai.ToolHandler {
@@ -296,16 +179,7 @@ func (a *agentImpl) planWrap(next ai.ToolHandler) ai.ToolHandler {
 		if call.Name == toolPlan {
 			return a.handlePlan(call)
 		}
-		if call.Name == toolDelegate {
-			if blocked := a.unfinishedPlanStepsBeforeDelegation(); len(blocked) > 0 {
-				return refused(call.ID, ai.RefusedApproval, "complete these plan steps before delegating: "+strings.Join(blocked, ", "))
-			}
-		}
-		res := next(ctx, call)
-		if res.Refused == "" && toolErrorMessage(res) == "" {
-			a.completeNextPlanStep()
-		}
-		return res
+		return next(ctx, call)
 	}
 }
 
@@ -375,204 +249,12 @@ func (a *agentImpl) approveWrap(next ai.ToolHandler) ai.ToolHandler {
 // handlePlan persists the supplied plan to the agent's memory and
 // echoes it back so the model can see the stored state.
 func (a *agentImpl) handlePlan(call ai.ToolCall) ai.ToolResult {
-	input := preserveCompletedPlanSteps(a.loadPlan(), call.Input)
-	data, err := json.Marshal(input)
+	data, err := json.Marshal(call.Input)
 	if err != nil {
 		return errResult(call.ID, "invalid plan: "+err.Error())
 	}
 	_ = a.stateStore().Write(&store.Record{Key: planKey, Value: data})
-	return ai.ToolResult{ID: call.ID, Value: input, Content: string(data)}
-}
-
-func preserveCompletedPlanSteps(stored string, input map[string]any) map[string]any {
-	if stored == "" {
-		return input
-	}
-	var previous map[string]any
-	if err := json.Unmarshal([]byte(stored), &previous); err != nil {
-		return input
-	}
-	completed := completedPlanTasks(previous)
-	if len(completed) == 0 {
-		return input
-	}
-	steps, ok := input["steps"].([]any)
-	if !ok {
-		return input
-	}
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		task, _ := step["task"].(string)
-		if completed[planTaskCompletionKey(task)] && isUnfinishedPlanStatus(step["status"]) {
-			step["status"] = "done"
-		}
-	}
-	return input
-}
-
-func completedPlanTasks(plan map[string]any) map[string]bool {
-	steps, ok := plan["steps"].([]any)
-	if !ok {
-		return nil
-	}
-	completed := map[string]bool{}
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		status, _ := step["status"].(string)
-		if status != "done" {
-			continue
-		}
-		task, _ := step["task"].(string)
-		if task = planTaskCompletionKey(task); task != "" {
-			completed[task] = true
-		}
-	}
-	return completed
-}
-
-func normalizePlanTask(task string) string {
-	return strings.Join(strings.Fields(strings.ToLower(task)), " ")
-}
-
-func planTaskCompletionKey(task string) string {
-	normalized := normalizePlanTask(task)
-	if normalized == "" {
-		return ""
-	}
-	if isLaunchReadinessDelegationPlanTask(normalized) {
-		return "launch-readiness-notification"
-	}
-	return normalized
-}
-
-func isLaunchReadinessDelegationPlanTask(task string) bool {
-	task = normalizePlanTask(task)
-	if !strings.Contains(task, "notify") && !strings.Contains(task, "notification") {
-		return false
-	}
-	hasLaunchReadiness := strings.Contains(task, "launch") || strings.Contains(task, "readiness") || strings.Contains(task, "ready")
-	hasOwnerComms := strings.Contains(task, "owner") && strings.Contains(task, "comms")
-	return hasLaunchReadiness || hasOwnerComms
-}
-
-func isUnfinishedPlanStatus(status any) bool {
-	s, _ := status.(string)
-	return s == "" || s == "pending" || s == "in_progress"
-}
-
-func (a *agentImpl) completeNextPlanStep() {
-	plan := a.loadPlan()
-	if plan == "" {
-		return
-	}
-	var data map[string]any
-	if err := json.Unmarshal([]byte(plan), &data); err != nil {
-		return
-	}
-	steps, ok := data["steps"].([]any)
-	if !ok {
-		return
-	}
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		status, _ := step["status"].(string)
-		if status == "" || status == "pending" || status == "in_progress" {
-			step["status"] = "done"
-			b, err := json.Marshal(data)
-			if err == nil {
-				_ = a.stateStore().Write(&store.Record{Key: planKey, Value: b})
-			}
-			return
-		}
-	}
-}
-
-func (a *agentImpl) unfinishedPlanStepsBeforeDelegation() []string {
-	plan := a.loadPlan()
-	if plan == "" {
-		return nil
-	}
-	var data map[string]any
-	if err := json.Unmarshal([]byte(plan), &data); err != nil {
-		return nil
-	}
-	steps, ok := data["steps"].([]any)
-	if !ok {
-		return nil
-	}
-	var unfinished []string
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		task := planStepTask(step)
-		if isDelegationPlanTask(task) {
-			break
-		}
-		if !isUnfinishedPlanStatus(step["status"]) {
-			continue
-		}
-		if task == "" {
-			task = "<unnamed>"
-		}
-		unfinished = append(unfinished, task)
-	}
-	return unfinished
-}
-
-func planStepTask(step map[string]any) string {
-	if task, _ := step["task"].(string); task != "" {
-		return task
-	}
-	desc, _ := step["description"].(string)
-	return desc
-}
-
-func isDelegationPlanTask(task string) bool {
-	task = normalizePlanTask(task)
-	return strings.Contains(task, "delegate") || strings.Contains(task, "notify") || strings.Contains(task, "notification")
-}
-
-func (a *agentImpl) unfinishedPlanSteps() []string {
-	plan := a.loadPlan()
-	if plan == "" {
-		return nil
-	}
-	var data map[string]any
-	if err := json.Unmarshal([]byte(plan), &data); err != nil {
-		return nil
-	}
-	steps, ok := data["steps"].([]any)
-	if !ok {
-		return nil
-	}
-	var unfinished []string
-	for _, raw := range steps {
-		step, ok := raw.(map[string]any)
-		if !ok {
-			continue
-		}
-		status, _ := step["status"].(string)
-		if status != "" && status != "pending" && status != "in_progress" {
-			continue
-		}
-		task := planStepTask(step)
-		if task == "" {
-			task = "<unnamed>"
-		}
-		unfinished = append(unfinished, task)
-	}
-	return unfinished
+	return ai.ToolResult{ID: call.ID, Value: call.Input, Content: string(data)}
 }
 
 // handleHumanInput records that the model needs operator input before it can continue.
@@ -590,22 +272,13 @@ 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) (res ai.ToolResult) {
+func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 	input := call.Input
 	task, _ := input["task"].(string)
 	if task == "" {
 		return errResult(call.ID, "task is required")
 	}
 	to, _ := input["to"].(string)
-	if cached, ok := a.cachedDelegateResult(call.ID, to, task); ok {
-		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://") {
@@ -613,7 +286,9 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 		if err != nil {
 			return errResult(call.ID, "delegate to A2A agent "+to+": "+err.Error())
 		}
-		return a.storeDelegateResult(call.ID, to, task, map[string]any{"agent": to, "reply": reply})
+		out := map[string]any{"agent": to, "reply": reply}
+		b, _ := json.Marshal(out)
+		return ai.ToolResult{ID: call.ID, Value: out, Content: string(b)}
 	}
 
 	// Delegate-first: an existing agent that owns the domain handles it.
@@ -622,7 +297,9 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 		if err != nil {
 			return errResult(call.ID, "delegate to agent "+to+": "+err.Error())
 		}
-		return a.storeDelegateResult(call.ID, to, task, map[string]any{"agent": to, "reply": reply})
+		out := map[string]any{"agent": to, "reply": reply}
+		b, _ := json.Marshal(out)
+		return ai.ToolResult{ID: call.ID, Value: out, Content: string(b)}
 	}
 
 	// Otherwise create a focused, ephemeral sub-agent. Fresh context:
@@ -642,10 +319,6 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 		WithRegistry(a.opts.Registry),
 		WithClient(a.opts.Client),
 		WithStore(a.opts.Store),
-		ModelCallTimeout(a.opts.ModelTimeout),
-		ModelRetry(a.opts.ModelMaxAttempts, a.opts.ModelRetryBackoff),
-		ToolCallTimeout(a.opts.ToolTimeout),
-		ToolRetry(a.opts.ToolMaxAttempts, a.opts.ToolRetryBackoff),
 		TraceProvider(a.opts.TraceProvider),
 	)
 	// Record lineage so the sub-agent's tool calls carry this run as parent.
@@ -655,97 +328,9 @@ func (a *agentImpl) handleDelegate(ctx context.Context, call ai.ToolCall) (res a
 	if err != nil {
 		return errResult(call.ID, "sub-agent: "+err.Error())
 	}
-	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 {
-		return ai.ToolResult{}, false
-	}
-	var out map[string]any
-	if err := json.Unmarshal(recs[0].Value, &out); err != nil {
-		return ai.ToolResult{}, false
-	}
+	out := map[string]any{"reply": resp.Reply}
 	b, _ := json.Marshal(out)
-	return ai.ToolResult{ID: id, Value: out, Content: string(b)}, true
-}
-
-func (a *agentImpl) storeDelegateResult(id, to, task string, out map[string]any) ai.ToolResult {
-	b, _ := json.Marshal(out)
-	_ = a.stateStore().Write(&store.Record{Key: delegateResultKey(to, task), Value: b})
-	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))
-	return fmt.Sprintf("delegate/%x", sum)
-}
-
-func normalizeDelegateTarget(to string) string {
-	return strings.Join(strings.Fields(strings.ToLower(strings.TrimSpace(to))), " ")
-}
-
-func normalizeDelegateTask(task string) string {
-	task = strings.ToLower(strings.TrimSpace(task))
-	task = strings.Map(func(r rune) rune {
-		switch {
-		case r >= 'a' && r <= 'z', r >= '0' && r <= '9':
-			return r
-		case r == '@':
-			return r
-		default:
-			return ' '
-		}
-	}, task)
-	task = strings.Join(strings.Fields(task), " ")
-	if strings.Contains(task, "notify") &&
-		strings.Contains(task, "owner") &&
-		strings.Contains(task, "acme") &&
-		strings.Contains(task, "launch") &&
-		strings.Contains(task, "plan") &&
-		(strings.Contains(task, "ready") || strings.Contains(task, "readiness") || strings.Contains(task, "prepared") || strings.Contains(task, "complete")) {
-		return "notify owner@acme.com launch-plan-ready"
-	}
-	return task
+	return ai.ToolResult{ID: call.ID, Value: out, Content: string(b)}
 }
 
 // isAgent reports whether name resolves to a registered agent (a

agent/builtin_test.go

@@ -1,11 +1,8 @@
 package agent
 
 import (
-	"context"
 	"encoding/json"
-	"sync"
 	"testing"
-	"time"
 
 	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/registry"
@@ -55,53 +52,6 @@ func TestHandlePlanPersists(t *testing.T) {
 	}
 }
 
-func TestHandlePlanPreservesCompletedSteps(t *testing.T) {
-	mem := store.NewMemoryStore()
-	a := New(Name("planner"), WithStore(mem)).(*agentImpl)
-
-	a.handlePlan(ai.ToolCall{Name: "plan", Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "create Design task", "status": "done"},
-			map[string]any{"task": "Delegate readiness notification to comms agent", "status": "done"},
-		},
-	}})
-
-	res := a.handlePlan(ai.ToolCall{Name: "plan", Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "create Design task", "status": "done"},
-			map[string]any{"task": "  delegate   readiness notification TO comms agent  ", "status": "in_progress"},
-			map[string]any{"task": "write summary", "status": "pending"},
-		},
-	}})
-	if res.Content == "" {
-		t.Fatal("handlePlan returned empty content")
-	}
-	if unfinished := a.unfinishedPlanSteps(); len(unfinished) != 1 || unfinished[0] != "write summary" {
-		t.Fatalf("unfinished plan steps = %v, want only write summary", unfinished)
-	}
-}
-
-func TestHandlePlanPreservesCompletedLaunchReadinessNotification(t *testing.T) {
-	mem := store.NewMemoryStore()
-	a := New(Name("planner"), WithStore(mem)).(*agentImpl)
-
-	a.handlePlan(ai.ToolCall{Name: toolPlan, Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "notify owner via comms", "status": "done"},
-		},
-	}})
-
-	a.handlePlan(ai.ToolCall{Name: toolPlan, Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "Delegate launch readiness notification for owner@acme.com to comms agent", "status": "in_progress"},
-		},
-	}})
-
-	if unfinished := a.unfinishedPlanSteps(); len(unfinished) != 0 {
-		t.Fatalf("unfinished plan steps = %v, want launch readiness notification preserved as done", unfinished)
-	}
-}
-
 func TestPlanShowsInPrompt(t *testing.T) {
 	mem := store.NewMemoryStore()
 	a := New(Name("planner"), Prompt("base prompt"), WithStore(mem)).(*agentImpl)
@@ -184,69 +134,6 @@ func TestBuiltinsAccessor(t *testing.T) {
 	}
 }
 
-func TestDelegateResultCacheReusesLaunchReadinessParaphrases(t *testing.T) {
-	mem := store.NewMemoryStore()
-	a := New(Name("planner"), WithStore(mem)).(*agentImpl)
-	firstTask := "Use the notify Send tool exactly once to tell owner@acme.com: The launch plan is ready."
-	first := a.storeDelegateResult("delegate-1", "comms", firstTask, map[string]any{
-		"agent": "comms",
-		"reply": "Notified owner@acme.com.",
-	})
-	if first.Content == "" {
-		t.Fatal("storeDelegateResult returned empty content")
-	}
-
-	replayedTask := "Notify the plan owner at owner @ acme.com that launch readiness is prepared and complete."
-	cached, ok := a.cachedDelegateResult("delegate-2", "  COMMS  ", replayedTask)
-	if !ok {
-		t.Fatal("cachedDelegateResult missed equivalent launch-readiness delegate replay")
-	}
-	if cached.ID != "delegate-2" {
-		t.Fatalf("cached result ID = %q, want replay call ID", cached.ID)
-	}
-	if !containsStr(cached.Content, "Notified owner@acme.com") {
-		t.Fatalf("cached result content = %q, want original delegate reply", cached.Content)
-	}
-}
-
-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()
 
@@ -278,45 +165,3 @@ func TestIsAgent(t *testing.T) {
 		t.Error("isAgent(nonexistent) = true, want false")
 	}
 }
-
-func TestPlanWrapBlocksDelegationUntilPriorPlanStepsFinish(t *testing.T) {
-	mem := store.NewMemoryStore()
-	a := New(Name("planner"), WithStore(mem)).(*agentImpl)
-	a.handlePlan(ai.ToolCall{Name: toolPlan, Input: map[string]any{
-		"steps": []any{
-			map[string]any{"task": "Create Design task", "status": "pending"},
-			map[string]any{"task": "Create Build task", "status": "pending"},
-			map[string]any{"task": "Create Ship task", "status": "pending"},
-			map[string]any{"task": "Delegate readiness notification to comms agent", "status": "pending"},
-		},
-	}})
-
-	called := false
-	handle := a.planWrap(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		called = true
-		return ai.ToolResult{ID: call.ID, Content: "ok"}
-	})
-
-	res := handle(context.Background(), ai.ToolCall{ID: "delegate-1", Name: toolDelegate, Input: map[string]any{"to": "comms"}})
-	if called {
-		t.Fatal("delegate handler was called before prior task plan steps completed")
-	}
-	if res.Refused == "" {
-		t.Fatalf("delegate result was not refused: %+v", res)
-	}
-	if got := res.Content; !containsStr(got, "Create Design task") || !containsStr(got, "Create Ship task") {
-		t.Fatalf("delegate refusal content = %q, want prior unfinished task steps", got)
-	}
-
-	for _, id := range []string{"add-design", "add-build", "add-ship"} {
-		_ = handle(context.Background(), ai.ToolCall{ID: id, Name: "task.Add", Input: map[string]any{"title": id}})
-	}
-	called = false
-	res = handle(context.Background(), ai.ToolCall{ID: "delegate-2", Name: toolDelegate, Input: map[string]any{"to": "comms"}})
-	if !called {
-		t.Fatal("delegate handler was not called after prior task plan steps completed")
-	}
-	if res.Refused != "" {
-		t.Fatalf("delegate result refused after prior task steps completed: %+v", res)
-	}
-}

agent/checkpoint.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"strings"
 	"time"
 
 	"go-micro.dev/v6/ai"
@@ -50,16 +49,6 @@ func (a *agentImpl) saveRun(ctx context.Context, run flow.Run) error {
 	if err := a.opts.Checkpoint.Save(ctx, run); err != nil {
 		return fmt.Errorf("agent %s checkpoint save: %w", a.opts.Name, err)
 	}
-	if info, ok := ai.RunInfoFrom(ctx); ok {
-		stage := run.State.Stage
-		if stage == "" && len(run.Steps) > 0 {
-			stage = run.Steps[0].Name
-		}
-		a.recordTimelineEvent(ctx, RunEvent{
-			Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent,
-			Kind: "checkpoint", Name: stage, Status: run.Status,
-		})
-	}
 	return nil
 }
 
@@ -99,9 +88,6 @@ func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error)
 		}
 		return &resp, nil
 	}
-	if terminalAgentRunStatus(run.Status) {
-		return nil, fmt.Errorf("agent run %s is terminal with status %q", runID, run.Status)
-	}
 	message := string(run.State.Data)
 	parentID := run.ParentID
 	a.mu.Lock()
@@ -109,7 +95,7 @@ func (a *agentImpl) resume(ctx context.Context, runID string) (*Response, error)
 	if a.model == nil {
 		a.setup()
 	}
-	return a.askLocked(ctx, run.ID, message, parentID, &run, false)
+	return a.askLocked(ctx, run.ID, message, parentID, &run)
 }
 
 // ResumeInput resumes a checkpointed agent run that paused via the built-in
@@ -154,7 +140,7 @@ func (a *agentImpl) resumeInput(ctx context.Context, runID, input string) (*Resp
 	if a.model == nil {
 		a.setup()
 	}
-	return a.askLocked(ctx, run.ID, message, run.ParentID, &run, true)
+	return a.askLocked(ctx, run.ID, message, run.ParentID, &run)
 }
 
 func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {
@@ -167,72 +153,13 @@ func (a *agentImpl) pending(ctx context.Context) ([]flow.Run, error) {
 	}
 	out := runs[:0]
 	for _, run := range runs {
-		if run.Flow == a.opts.Name && !terminalAgentRunStatus(run.Status) {
+		if run.Flow == a.opts.Name && run.Status != "done" {
 			out = append(out, run)
 		}
 	}
 	return out, nil
 }
 
-func terminalAgentRunStatus(status string) bool {
-	switch status {
-	case "done", "canceled", "timeout", "rate_limited", "expired":
-		return true
-	default:
-		return false
-	}
-}
-
-func agentRunFailureStatus(err error) string {
-	switch ai.ClassifyError(err) {
-	case ai.ErrorKindCanceled:
-		return "canceled"
-	case ai.ErrorKindTimeout:
-		return "timeout"
-	case ai.ErrorKindRateLimited:
-		return "rate_limited"
-	default:
-		return "failed"
-	}
-}
-
-type operationalError struct {
-	err  error
-	hint string
-}
-
-func (e *operationalError) Error() string {
-	if e == nil {
-		return ""
-	}
-	return e.err.Error() + "; " + e.hint
-}
-
-func (e *operationalError) Unwrap() error {
-	if e == nil {
-		return nil
-	}
-	return e.err
-}
-
-func agentOperationalError(err error) error {
-	if err == nil {
-		return nil
-	}
-	switch ai.ClassifyError(err) {
-	case ai.ErrorKindCanceled:
-		return &operationalError{err: err, hint: "agent run canceled; inspect run history with `micro inspect agent <name> --status canceled` or see docs/guides/debugging-agents.md"}
-	case ai.ErrorKindTimeout:
-		return &operationalError{err: err, hint: "agent provider call timed out; inspect run history with `micro inspect agent <name> --status timeout`, then adjust AgentModelCallTimeout/AgentModelRetry or see docs/guides/debugging-agents.md"}
-	case ai.ErrorKindRateLimited:
-		return &operationalError{err: err, hint: "agent provider was rate limited; inspect run history with `micro inspect agent <name> --status rate_limited`, check provider keys with `micro agent preflight`, or see docs/guides/debugging-agents.md"}
-	case ai.ErrorKindUnavailable:
-		return &operationalError{err: err, hint: "agent provider appears temporarily unavailable; retry with bounded AgentModelRetry and verify provider setup with `micro agent preflight` or docs/guides/debugging-agents.md"}
-	default:
-		return err
-	}
-}
-
 func (a *agentImpl) checkpointToolWrap(next ai.ToolHandler) ai.ToolHandler {
 	return func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
 		if a.opts.Checkpoint == nil || a.currentRun == nil {
@@ -289,56 +216,3 @@ func upsertStep(steps *[]flow.StepRecord, rec flow.StepRecord) int {
 	*steps = append(*steps, rec)
 	return len(*steps) - 1
 }
-
-func checkpointToolCalls(steps []flow.StepRecord) []ai.ToolCall {
-	calls := make([]ai.ToolCall, 0, len(steps))
-	for _, step := range steps {
-		call, ok := checkpointToolCall(step)
-		if !ok {
-			continue
-		}
-		calls = append(calls, call)
-	}
-	return calls
-}
-
-func checkpointToolCall(step flow.StepRecord) (ai.ToolCall, bool) {
-	if step.Status != "done" || !strings.HasPrefix(step.Name, "tool:") {
-		return ai.ToolCall{}, false
-	}
-	parts := strings.SplitN(strings.TrimPrefix(step.Name, "tool:"), ":", 2)
-	if len(parts) != 2 || parts[0] == "" {
-		return ai.ToolCall{}, false
-	}
-	input := map[string]any{}
-	if parts[1] != "null" && parts[1] != "" {
-		if err := json.Unmarshal([]byte(parts[1]), &input); err != nil {
-			return ai.ToolCall{}, false
-		}
-	}
-	return ai.ToolCall{Name: parts[0], Input: input, Result: step.Result}, true
-}
-
-func mergeCheckpointToolCalls(checkpointed, current []ai.ToolCall) []ai.ToolCall {
-	if len(checkpointed) == 0 {
-		return current
-	}
-	seen := make(map[string]struct{}, len(current))
-	for _, call := range current {
-		seen[toolCallKey(call.Name, call.Input)] = struct{}{}
-	}
-	merged := make([]ai.ToolCall, 0, len(checkpointed)+len(current))
-	for _, call := range checkpointed {
-		if _, ok := seen[toolCallKey(call.Name, call.Input)]; ok {
-			continue
-		}
-		merged = append(merged, call)
-	}
-	merged = append(merged, current...)
-	return merged
-}
-
-func toolCallKey(name string, input map[string]any) string {
-	b, _ := json.Marshal(input)
-	return name + ":" + string(b)
-}

agent/checkpoint_test.go

@@ -5,23 +5,19 @@ import (
 	"errors"
 	"strings"
 	"testing"
-	"time"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/client"
-	codecBytes "go-micro.dev/v6/codec/bytes"
 	"go-micro.dev/v6/flow"
-	"go-micro.dev/v6/registry"
 	"go-micro.dev/v6/store"
 )
 
 func TestResumeCompletedCheckpointDoesNotReplayModel(t *testing.T) {
 	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "durable-agent")
+	cp := flow.StoreCheckpoint(store.NewStore(), "durable-agent")
 	calls := 0
 	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
 		calls++
-		return &ai.Response{Reply: "done", ToolCalls: []ai.ToolCall{{ID: "call-1", Name: "external.lookup", Result: "cached"}}}, nil
+		return &ai.Response{Reply: "done"}, nil
 	}
 	defer func() { fakeGen = nil }()
 
@@ -49,9 +45,6 @@ func TestResumeCompletedCheckpointDoesNotReplayModel(t *testing.T) {
 	if resumed.RunID != resp.RunID {
 		t.Fatalf("resumed run id = %q, want %q", resumed.RunID, resp.RunID)
 	}
-	if len(resumed.ToolCalls) != 1 || resumed.ToolCalls[0].Name != "external.lookup" || resumed.ToolCalls[0].Result != "cached" {
-		t.Fatalf("resumed tool calls = %#v, want persisted completed call", resumed.ToolCalls)
-	}
 	if calls != 1 {
 		t.Fatalf("model calls after Resume = %d, want 1", calls)
 	}
@@ -59,7 +52,7 @@ func TestResumeCompletedCheckpointDoesNotReplayModel(t *testing.T) {
 
 func TestResumeFailedCheckpointDoesNotReplayCompletedTool(t *testing.T) {
 	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "tool-resume-agent")
+	cp := flow.StoreCheckpoint(store.NewStore(), "tool-resume-agent")
 	toolRuns := 0
 	first := true
 	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
@@ -104,487 +97,14 @@ func TestResumeFailedCheckpointDoesNotReplayCompletedTool(t *testing.T) {
 	if resp.Reply != "finished from checkpoint" {
 		t.Fatalf("Resume reply = %q", resp.Reply)
 	}
-	if len(resp.ToolCalls) != 1 || resp.ToolCalls[0].Name != "external.charge" || resp.ToolCalls[0].Result != "charged" {
-		t.Fatalf("resumed tool calls = %#v, want preserved completed charge call", resp.ToolCalls)
-	}
-	if got := resp.ToolCalls[0].Input["order"]; got != "42" {
-		t.Fatalf("resumed tool input order = %#v, want 42", got)
-	}
 	if toolRuns != 1 {
 		t.Fatalf("tool executions after Resume = %d, want completed tool was not replayed", toolRuns)
 	}
 }
 
-func TestCheckpointSkipsDuplicateToolWithinAsk(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "tool-dedupe-agent")
-	toolRuns := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		opts.ToolHandler(ctx, ai.ToolCall{ID: "plan-1", Name: toolPlan, Input: map[string]any{
-			"steps": []any{
-				map[string]any{"task": "create Design task", "status": "pending"},
-			},
-		}})
-		for i := 0; i < 3; i++ {
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "external.create", Input: map[string]any{"title": "Design"}})
-			if res.Content != "created Design" {
-				t.Fatalf("tool result %d = %q, want cached created Design", i, res.Content)
-			}
-		}
-		return &ai.Response{Reply: "done"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("tool-dedupe-agent"), WithCheckpoint(cp),
-		WithTool("external.create", "create once", nil, func(context.Context, map[string]any) (string, error) {
-			toolRuns++
-			return "created Design", nil
-		}))
-	if _, err := a.Ask(ctx, "create Design once"); err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions = %d, want duplicate calls within the run replayed from checkpoint", toolRuns)
-	}
-	if plan := a.loadPlan(); !strings.Contains(plan, `"status":"done"`) {
-		t.Fatalf("plan = %s, want completed action marked done", plan)
-	}
-}
-
-func TestCheckpointContinuesRunWithUnfinishedPlanStep(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "unfinished-plan-agent")
-
-	reg := registry.NewMemoryRegistry()
-	if err := reg.Register(&registry.Service{
-		Name:     "comms",
-		Metadata: map[string]string{"type": "agent"},
-		Nodes:    []*registry.Node{{Id: "comms-1", Address: "127.0.0.1:0"}},
-	}); err != nil {
-		t.Fatalf("register comms agent: %v", err)
-	}
-
-	delegateCalls := 0
-	fc := &fakeClient{Client: client.DefaultClient}
-	fc.callFn = func(ctx context.Context, req client.Request, rsp interface{}) error {
-		delegateCalls++
-		if req.Service() != "comms" || req.Endpoint() != "Agent.Chat" {
-			t.Fatalf("delegate RPC = %s %s, want comms Agent.Chat", req.Service(), req.Endpoint())
-		}
-		frame := rsp.(*codecBytes.Frame)
-		frame.Data = []byte(`{"reply":"owner notified","agent":"comms"}`)
-		return nil
-	}
-
-	modelCalls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		modelCalls++
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		switch modelCalls {
-		case 1:
-			opts.ToolHandler(ctx, ai.ToolCall{ID: "plan-1", Name: toolPlan, Input: map[string]any{
-				"steps": []any{
-					map[string]any{"task": "create launch tasks", "status": "done"},
-					map[string]any{"task": "delegate readiness notification to comms", "status": "in_progress"},
-				},
-			}})
-			return &ai.Response{Reply: "tasks are ready"}, nil
-		case 2:
-			if !strings.Contains(req.Prompt, "delegate readiness notification to comms") {
-				t.Fatalf("continuation prompt = %q, want unfinished step", req.Prompt)
-			}
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "delegate-1", Name: toolDelegate, Input: map[string]any{"task": "Notify owner@acme.com that the launch plan is ready", "to": "comms"}})
-			if !strings.Contains(res.Content, "owner notified") {
-				t.Fatalf("delegate result = %q, want owner notified", res.Content)
-			}
-			return &ai.Response{Reply: "all done"}, nil
-		default:
-			t.Fatalf("unexpected model call %d", modelCalls)
-			return nil, nil
-		}
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("unfinished-plan-agent"), WithCheckpoint(cp), WithRegistry(reg), WithClient(fc))
-	resp, err := a.Ask(ctx, "create tasks and notify owner")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if resp.Reply != "all done" {
-		t.Fatalf("reply = %q, want final continuation reply", resp.Reply)
-	}
-	if modelCalls != 2 {
-		t.Fatalf("model calls = %d, want initial plus continuation", modelCalls)
-	}
-	if delegateCalls != 1 {
-		t.Fatalf("delegate calls = %d, want exactly one", delegateCalls)
-	}
-	if unfinished := a.unfinishedPlanSteps(); len(unfinished) != 0 {
-		t.Fatalf("unfinished plan steps = %v, want none", unfinished)
-	}
-}
-
-func TestCheckpointContinuesRunThroughSeveralSingleStepTurns(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "single-step-plan-agent")
-
-	completed := []string{}
-	modelCalls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		modelCalls++
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		switch modelCalls {
-		case 1:
-			opts.ToolHandler(ctx, ai.ToolCall{ID: "plan-1", Name: toolPlan, Input: map[string]any{
-				"steps": []any{
-					map[string]any{"task": "create Design task", "status": "pending"},
-					map[string]any{"task": "create Build task", "status": "pending"},
-					map[string]any{"task": "create Ship task", "status": "pending"},
-					map[string]any{"task": "delegate readiness notification", "status": "pending"},
-				},
-			}})
-			return &ai.Response{Reply: "planned"}, nil
-		case 2, 3, 4, 5:
-			want := []string{"create Design task", "create Build task", "create Ship task", "delegate readiness notification"}[modelCalls-2]
-			if !strings.Contains(req.Prompt, want) {
-				t.Fatalf("continuation prompt %d = %q, want %q", modelCalls, req.Prompt, want)
-			}
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: want, Name: "external.step", Input: map[string]any{"step": want}})
-			if res.Content != "completed "+want {
-				t.Fatalf("tool result = %q, want completed %s", res.Content, want)
-			}
-			if modelCalls == 5 {
-				return &ai.Response{Reply: "all plan steps complete"}, nil
-			}
-			return &ai.Response{Reply: "one more step complete"}, nil
-		default:
-			t.Fatalf("unexpected model call %d", modelCalls)
-			return nil, nil
-		}
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("single-step-plan-agent"), WithCheckpoint(cp),
-		WithTool("external.step", "complete one planned step", nil, func(ctx context.Context, input map[string]any) (string, error) {
-			step, _ := input["step"].(string)
-			completed = append(completed, step)
-			return "completed " + step, nil
-		}))
-	resp, err := a.Ask(ctx, "work through the launch plan")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if resp.Reply != "all plan steps complete" {
-		t.Fatalf("reply = %q, want final continuation reply", resp.Reply)
-	}
-	if modelCalls != 5 {
-		t.Fatalf("model calls = %d, want initial plus four continuations", modelCalls)
-	}
-	if len(completed) != 4 {
-		t.Fatalf("completed steps = %v, want four tool-backed continuations", completed)
-	}
-	if unfinished := a.unfinishedPlanSteps(); len(unfinished) != 0 {
-		t.Fatalf("unfinished plan steps = %v, want none", unfinished)
-	}
-}
-
-func TestResumeFailedCheckpointAfterFreshAgentRestart(t *testing.T) {
-	ctx := context.Background()
-	st := store.NewMemoryStore()
-	cp := flow.StoreCheckpoint(st, "restart-resume-agent")
-	toolRuns := 0
-	modelCalls := 0
-	failFirst := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		modelCalls++
-		if opts.ToolHandler != nil {
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "external.provision", Input: map[string]any{"service": "api"}})
-			if res.Content != "provisioned" {
-				t.Fatalf("tool result = %q, want provisioned", res.Content)
-			}
-		}
-		if failFirst {
-			failFirst = false
-			return nil, errors.New("process stopped after tool checkpoint")
-		}
-		return &ai.Response{Reply: "resumed after restart"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	newAgent := func() *agentImpl {
-		return newTestAgent(Name("restart-resume-agent"), WithStore(st), WithCheckpoint(cp),
-			WithTool("external.provision", "provision service once", nil, func(context.Context, map[string]any) (string, error) {
-				toolRuns++
-				return "provisioned", nil
-			}))
-	}
-
-	first := newAgent()
-	_, err := first.Ask(ctx, "provision api")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated process stop")
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after failed Ask = %d, want 1", toolRuns)
-	}
-	runs, err := Pending(ctx, first)
-	if err != nil {
-		t.Fatalf("Pending before restart: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("Pending before restart returned %d runs, want 1", len(runs))
-	}
-	summaries, err := ListRunSummaries(st, "restart-resume-agent")
-	if err != nil {
-		t.Fatalf("ListRunSummaries before restart: %v", err)
-	}
-	if len(summaries) != 1 {
-		t.Fatalf("run summaries before restart = %d, want 1", len(summaries))
-	}
-	if summaries[0].RunID != runs[0].ID || summaries[0].Status != "error" || summaries[0].Checkpoint != "failed" || summaries[0].Stage != agentAskStep {
-		t.Fatalf("summary before restart = %#v, want failed ask checkpoint for %s", summaries[0], runs[0].ID)
-	}
-	if summaries[0].Events < 4 || summaries[0].LastError == "" {
-		t.Fatalf("summary before restart lacks debug history/error: %#v", summaries[0])
-	}
-
-	restarted := newAgent()
-	resp, err := Resume(ctx, restarted, runs[0].ID)
-	if err != nil {
-		t.Fatalf("Resume after restart: %v", err)
-	}
-	if resp.Reply != "resumed after restart" || resp.RunID != runs[0].ID {
-		t.Fatalf("response = %#v, want resumed reply on original run id", resp)
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after restart resume = %d, want checkpointed tool not replayed", toolRuns)
-	}
-	if modelCalls != 2 {
-		t.Fatalf("model calls = %d, want initial call plus resumed call", modelCalls)
-	}
-	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" || loaded.ParentID != runs[0].ParentID {
-		t.Fatalf("loaded run status/parent = %s/%s, want done/%s", loaded.Status, loaded.ParentID, runs[0].ParentID)
-	}
-	summaries, err = ListRunSummaries(st, "restart-resume-agent")
-	if err != nil {
-		t.Fatalf("ListRunSummaries after restart: %v", err)
-	}
-	if len(summaries) != 1 {
-		t.Fatalf("run summaries after restart = %d, want 1", len(summaries))
-	}
-	if summaries[0].RunID != runs[0].ID || summaries[0].Status != "done" || summaries[0].Checkpoint != "done" || summaries[0].Stage != agentAskStep {
-		t.Fatalf("summary after restart = %#v, want done ask checkpoint for %s", summaries[0], runs[0].ID)
-	}
-	if summaries[0].Events < 7 {
-		t.Fatalf("summary after restart recorded %d events, want durable failure/resume/done history", summaries[0].Events)
-	}
-	events, err := LoadRunEvents(st, "restart-resume-agent", runs[0].ID)
-	if err != nil {
-		t.Fatalf("LoadRunEvents after restart: %v", err)
-	}
-	seen := map[string]bool{"run": false, "tool": false, "checkpoint": false, "error": false, "resume": false, "done": false}
-	for _, e := range events {
-		if _, ok := seen[e.Kind]; ok {
-			seen[e.Kind] = true
-		}
-	}
-	for kind, ok := range seen {
-		if !ok {
-			t.Fatalf("events after restart missing %s: %#v", kind, events)
-		}
-	}
-}
-
-func TestResumePendingAfterFreshAgentRestartDoesNotReplayCompletedTool(t *testing.T) {
-	ctx := context.Background()
-	st := store.NewMemoryStore()
-	cp := flow.StoreCheckpoint(st, "startup-resume-agent")
-	toolRuns := 0
-	failFirst := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler != nil {
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "external.allocate", Input: map[string]any{"cluster": "blue"}})
-			if res.Content != "allocated" {
-				t.Fatalf("tool result = %q, want allocated", res.Content)
-			}
-		}
-		if failFirst {
-			failFirst = false
-			return nil, errors.New("process stopped before final response")
-		}
-		return &ai.Response{Reply: "startup recovery complete"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	newAgent := func() *agentImpl {
-		return newTestAgent(Name("startup-resume-agent"), WithStore(st), WithCheckpoint(cp),
-			WithTool("external.allocate", "allocate capacity once", nil, func(context.Context, map[string]any) (string, error) {
-				toolRuns++
-				return "allocated", nil
-			}))
-	}
-
-	first := newAgent()
-	_, err := first.Ask(ctx, "allocate blue capacity")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated process stop")
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after failed Ask = %d, want 1", toolRuns)
-	}
-
-	restarted := newAgent()
-	failedRun, err := ResumePending(ctx, restarted)
-	if err != nil {
-		t.Fatalf("ResumePending after restart: failedRun=%q err=%v", failedRun, err)
-	}
-	if failedRun != "" {
-		t.Fatalf("failed run = %q, want none", failedRun)
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after ResumePending = %d, want completed tool not replayed", toolRuns)
-	}
-	runs, err := Pending(ctx, restarted)
-	if err != nil {
-		t.Fatalf("Pending after ResumePending: %v", err)
-	}
-	if len(runs) != 0 {
-		t.Fatalf("Pending after ResumePending = %#v, want none", runs)
-	}
-	summaries, err := ListRunSummaries(st, "startup-resume-agent")
-	if err != nil {
-		t.Fatalf("ListRunSummaries after ResumePending: %v", err)
-	}
-	if len(summaries) != 1 || summaries[0].Status != "done" || summaries[0].Checkpoint != "done" {
-		t.Fatalf("summary after ResumePending = %#v, want one done run", summaries)
-	}
-}
-
-func TestResumeFailedCheckpointDoesNotDuplicateCompactedMemory(t *testing.T) {
-	ctx := context.Background()
-	st := store.NewMemoryStore()
-	cp := flow.StoreCheckpoint(st, "memory-resume-agent")
-	failRetry := true
-	var sawRecall bool
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		for _, msg := range req.Messages {
-			if text, ok := msg.Content.(string); ok && strings.Contains(text, "alpha code is 42") {
-				sawRecall = true
-			}
-		}
-		if strings.Contains(req.Prompt, "use alpha code") && failRetry {
-			failRetry = false
-			return nil, errors.New("model connection dropped")
-		}
-		return &ai.Response{Reply: "ok"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("memory-resume-agent"), WithStore(st), WithCheckpoint(cp), CompactMemory(4, 1), MemoryRecallLimit(2))
-	for _, msg := range []string{"alpha code is 42", "beta note", "gamma note"} {
-		if _, err := a.Ask(ctx, msg); err != nil {
-			t.Fatalf("Ask(%q): %v", msg, err)
-		}
-	}
-
-	_, err := a.Ask(ctx, "use alpha code now")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated provider failure")
-	}
-	if got := countMemoryContent(a.mem.Messages(), "use alpha code now"); got != 1 {
-		t.Fatalf("failed Ask stored prompt %d times, want 1", got)
-	}
-
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("Pending returned %d runs, want 1", len(runs))
-	}
-	if _, err := Resume(ctx, a, runs[0].ID); err != nil {
-		t.Fatalf("Resume: %v", err)
-	}
-	if got := countMemoryContent(a.mem.Messages(), "use alpha code now"); got != 1 {
-		t.Fatalf("resumed failed Ask stored prompt %d times, want no duplicate", got)
-	}
-	if !sawRecall {
-		t.Fatal("resume did not retrieve archived compacted memory")
-	}
-	if got := len(a.mem.Messages()); got > 4 {
-		t.Fatalf("compacted memory retained %d messages after resume, want <= 4", got)
-	}
-}
-
-func countMemoryContent(messages []ai.Message, needle string) int {
-	var count int
-	for _, msg := range messages {
-		if text, ok := msg.Content.(string); ok && strings.Contains(text, needle) {
-			count++
-		}
-	}
-	return count
-}
-
-func TestResumePendingResumesOldestAgentRunsUntilFailure(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "resume-pending-agent")
-	base := time.Date(2026, 7, 7, 12, 0, 0, 0, time.UTC)
-	for _, run := range []flow.Run{
-		{ID: "run-ok", Flow: "resume-pending-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("ok")}, Started: base},
-		{ID: "run-blocked", Flow: "resume-pending-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("block")}, Started: base.Add(time.Minute)},
-		{ID: "run-later", Flow: "resume-pending-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("later")}, Started: base.Add(2 * time.Minute)},
-	} {
-		if err := cp.Save(ctx, run); err != nil {
-			t.Fatalf("Save(%s): %v", run.ID, err)
-		}
-	}
-
-	var prompts []string
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		prompts = append(prompts, req.Prompt)
-		if req.Prompt == "block" {
-			return nil, errors.New("still blocked")
-		}
-		return &ai.Response{Reply: req.Prompt + " resumed"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("resume-pending-agent"), WithCheckpoint(cp))
-	failedRun, err := ResumePending(ctx, a)
-	if err == nil {
-		t.Fatal("ResumePending succeeded, want blocked run error")
-	}
-	if failedRun != "run-blocked" {
-		t.Fatalf("failed run = %q, want run-blocked", failedRun)
-	}
-	if got, want := strings.Join(prompts, ","), "ok,block"; got != want {
-		t.Fatalf("prompts = %q, want %q", got, want)
-	}
-	loaded, ok, err := cp.Load(ctx, "run-ok")
-	if err != nil || !ok || loaded.Status != "done" {
-		t.Fatalf("run-ok loaded=%v err=%v status=%q, want done", ok, err, loaded.Status)
-	}
-	loaded, ok, err = cp.Load(ctx, "run-later")
-	if err != nil || !ok || loaded.Status != "failed" {
-		t.Fatalf("run-later loaded=%v err=%v status=%q, want still failed", ok, err, loaded.Status)
-	}
-}
-
 func TestPendingReturnsUnfinishedAgentRuns(t *testing.T) {
 	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "pending-agent")
+	cp := flow.StoreCheckpoint(store.NewStore(), "pending-agent")
 	run := flow.Run{ID: "run-1", Flow: "pending-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("retry me")}}
 	if err := cp.Save(ctx, run); err != nil {
 		t.Fatalf("Save: %v", err)
@@ -599,38 +119,9 @@ func TestPendingReturnsUnfinishedAgentRuns(t *testing.T) {
 	}
 }
 
-func TestPendingSkipsTerminalCanceledAndExpiredAgentRuns(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "terminal-agent")
-	for _, run := range []flow.Run{
-		{ID: "active", Flow: "terminal-agent", Status: "failed", State: flow.State{Stage: agentAskStep, Data: []byte("retry me")}},
-		{ID: "done", Flow: "terminal-agent", Status: "done", State: flow.State{Stage: agentAskStep, Data: []byte("done")}},
-		{ID: "canceled", Flow: "terminal-agent", Status: "canceled", State: flow.State{Stage: agentAskStep, Data: []byte("canceled")}},
-		{ID: "expired", Flow: "terminal-agent", Status: "expired", State: flow.State{Stage: agentAskStep, Data: []byte("expired")}},
-	} {
-		if err := cp.Save(ctx, run); err != nil {
-			t.Fatalf("Save(%s): %v", run.ID, err)
-		}
-	}
-
-	a := newTestAgent(Name("terminal-agent"), WithCheckpoint(cp))
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 || runs[0].ID != "active" {
-		t.Fatalf("Pending = %#v, want only active failed run", runs)
-	}
-	for _, id := range []string{"canceled", "expired"} {
-		if _, err := Resume(ctx, a, id); err == nil || !strings.Contains(err.Error(), "terminal") {
-			t.Fatalf("Resume(%s) err = %v, want terminal status error", id, err)
-		}
-	}
-}
-
 func TestHumanInputPauseResumesSameRunWithInput(t *testing.T) {
 	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "input-agent")
+	cp := flow.StoreCheckpoint(store.NewStore(), "input-agent")
 	calls := 0
 	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
 		calls++
@@ -686,54 +177,9 @@ func TestHumanInputPauseResumesSameRunWithInput(t *testing.T) {
 	}
 }
 
-func TestHumanInputResumeHonorsCanceledContextAndLeavesRunPending(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "input-cancel-agent")
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler != nil {
-			opts.ToolHandler(ctx, ai.ToolCall{ID: "input-1", Name: toolHumanInput, Input: map[string]any{"prompt": "Approve deploy?"}})
-		}
-		return &ai.Response{Reply: "waiting"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("input-cancel-agent"), WithCheckpoint(cp))
-	if _, err := a.Ask(ctx, "deploy the service"); 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 {
-		t.Fatalf("Pending returned %d runs, want 1: %#v", len(runs), runs)
-	}
-
-	canceled, cancel := context.WithCancel(ctx)
-	cancel()
-	if _, err := ResumeInput(canceled, a, runs[0].ID, "yes"); !errors.Is(err, context.Canceled) {
-		t.Fatalf("ResumeInput canceled err = %v, want context.Canceled", err)
-	}
-
-	loaded, ok, err := cp.Load(ctx, runs[0].ID)
-	if err != nil || !ok {
-		t.Fatalf("Load paused run ok=%v err=%v", ok, err)
-	}
-	if loaded.Status != "paused" || loaded.State.Stage != agentInputStep {
-		t.Fatalf("run status/stage after canceled resume = %s/%s, want paused/%s", loaded.Status, loaded.State.Stage, agentInputStep)
-	}
-	var pause inputPause
-	if err := loaded.State.Scan(&pause); err != nil {
-		t.Fatalf("Scan pause after canceled resume: %v", err)
-	}
-	if pause.OriginalMessage != "deploy the service" || pause.Prompt != "Approve deploy?" {
-		t.Fatalf("pause after canceled resume = %#v", pause)
-	}
-}
-
 func TestApprovalDenialPausesCheckpointedRunAndResumeContinues(t *testing.T) {
 	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "approval-agent")
+	cp := flow.StoreCheckpoint(store.NewStore(), "approval-agent")
 	calls := 0
 	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
 		calls++

agent/conformance_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"io"
 	"os"
 	"strings"
 	"testing"
@@ -34,139 +33,14 @@ func TestAgentProviderConformanceMatrix(t *testing.T) {
 		{name: "together", key: "TOGETHER_API_KEY", model: "GO_MICRO_CONFORMANCE_TOGETHER_MODEL", live: true},
 	}
 
-	selected := selectedConformanceProviders(os.Getenv("GO_MICRO_AGENT_CONFORMANCE_PROVIDERS"))
 	for _, provider := range providers {
 		provider := provider
-		if len(selected) > 0 && !selected[provider.name] {
-			continue
-		}
 		t.Run(provider.name, func(t *testing.T) {
 			runAgentConformanceScenario(t, provider)
 		})
 	}
 }
 
-func TestAgentProviderStreamConformanceMatrix(t *testing.T) {
-	providers := []conformanceProvider{
-		{name: "fake"},
-		{name: "openai", key: "OPENAI_API_KEY", model: "GO_MICRO_CONFORMANCE_OPENAI_MODEL", live: true},
-		{name: "anthropic", key: "ANTHROPIC_API_KEY", model: "GO_MICRO_CONFORMANCE_ANTHROPIC_MODEL", live: true},
-		{name: "atlascloud", key: "ATLASCLOUD_API_KEY", model: "GO_MICRO_CONFORMANCE_ATLASCLOUD_MODEL", live: true},
-		{name: "groq", key: "GROQ_API_KEY", model: "GO_MICRO_CONFORMANCE_GROQ_MODEL", live: true},
-		{name: "minimax", key: "MINIMAX_API_KEY", model: "GO_MICRO_CONFORMANCE_MINIMAX_MODEL", live: true},
-		{name: "mistral", key: "MISTRAL_API_KEY", model: "GO_MICRO_CONFORMANCE_MISTRAL_MODEL", live: true},
-		{name: "together", key: "TOGETHER_API_KEY", model: "GO_MICRO_CONFORMANCE_TOGETHER_MODEL", live: true},
-	}
-
-	selected := selectedConformanceProviders(os.Getenv("GO_MICRO_AGENT_CONFORMANCE_PROVIDERS"))
-	for _, provider := range providers {
-		provider := provider
-		if len(selected) > 0 && !selected[provider.name] {
-			continue
-		}
-		t.Run(provider.name, func(t *testing.T) {
-			runAgentStreamConformanceScenario(t, provider)
-		})
-	}
-}
-
-func runAgentStreamConformanceScenario(t *testing.T, provider conformanceProvider) {
-	t.Helper()
-	if provider.live {
-		if os.Getenv(provider.key) == "" {
-			t.Skipf("%s not set; skipping live %s stream conformance", provider.key, provider.name)
-		}
-		if os.Getenv("GO_MICRO_AGENT_CONFORMANCE_LIVE") == "" {
-			t.Skipf("GO_MICRO_AGENT_CONFORMANCE_LIVE not set; skipping live %s stream conformance", provider.name)
-		}
-		if caps := ai.ProviderCapabilities(provider.name); !caps.Stream {
-			t.Fatalf("ProviderCapabilities(%q).Stream = false, want true for stream conformance", provider.name)
-		}
-	} else {
-		var sawToolSchema bool
-		fakeStream = func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error) {
-			if req.Prompt != "Stream exactly: agent-stream-conformance-ok" {
-				return nil, fmt.Errorf("prompt = %q", req.Prompt)
-			}
-			if len(req.Messages) == 0 || req.Messages[len(req.Messages)-1].Role != "user" || req.Messages[len(req.Messages)-1].Content != req.Prompt {
-				return nil, fmt.Errorf("messages = %#v, want current user turn", req.Messages)
-			}
-			for _, tool := range req.Tools {
-				if tool.Name == "conformance_echo" {
-					sawToolSchema = true
-				}
-			}
-			if !sawToolSchema {
-				return nil, errors.New("stream request omitted conformance tool schema")
-			}
-			return &sliceStream{chunks: []string{"agent-stream-", "conformance-ok"}}, nil
-		}
-		defer func() { fakeStream = nil }()
-	}
-
-	agentOpts := []Option{
-		Name("stream-conformance-" + provider.name),
-		Provider(provider.name),
-		APIKey(os.Getenv(provider.key)),
-		Prompt("Stream conformance: preserve the exact requested marker in the final answer."),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(8)),
-		ModelCallTimeout(45 * time.Second),
-		WithTool("conformance_echo", "Echo a conformance value and return a deterministic marker.", map[string]any{
-			"value": map[string]any{"type": "string", "description": "value to echo"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			return `{"marker":"agent-stream-conformance-ok"}`, nil
-		}),
-	}
-	if provider.model != "" {
-		if model := os.Getenv(provider.model); model != "" {
-			agentOpts = append(agentOpts, Model(model))
-		}
-	}
-
-	stream, err := New(agentOpts...).Stream(context.Background(), "Stream exactly: agent-stream-conformance-ok")
-	if err != nil {
-		t.Fatalf("Stream: %v", err)
-	}
-	defer stream.Close()
-
-	var reply strings.Builder
-	deadline := time.After(45 * time.Second)
-	for {
-		select {
-		case <-deadline:
-			t.Fatal("timed out waiting for streamed final output")
-		default:
-		}
-		chunk, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv: %v", err)
-		}
-		reply.WriteString(chunk.Reply)
-		if strings.Contains(reply.String(), "agent-stream-conformance-ok") {
-			return
-		}
-	}
-	if got := reply.String(); !strings.Contains(got, "agent-stream-conformance-ok") {
-		t.Fatalf("streamed reply %q does not include conformance marker", got)
-	}
-}
-
-func selectedConformanceProviders(csv string) map[string]bool {
-	out := map[string]bool{}
-	for _, part := range strings.Split(csv, ",") {
-		part = strings.TrimSpace(part)
-		if part != "" {
-			out[part] = true
-		}
-	}
-	return out
-}
-
 func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 	t.Helper()
 	if provider.live {
@@ -178,45 +52,30 @@ func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 		}
 	} else {
 		fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-			if err := validateConformanceRequest(req, opts); err != nil {
-				return nil, err
+			if req.Prompt == "" {
+				return nil, errors.New("missing prompt")
 			}
-
-			plan := opts.ToolHandler(ctx, ai.ToolCall{
-				ID:   "fake-plan-1",
-				Name: "plan",
-				Input: map[string]any{"steps": []map[string]any{
-					{"description": "call conformance_echo", "status": "pending"},
-					{"description": "attempt guarded delegate", "status": "pending"},
-				}},
-			})
-			echo := opts.ToolHandler(ctx, ai.ToolCall{
+			if len(req.Messages) == 0 || req.Messages[len(req.Messages)-1].Role != "user" {
+				return nil, fmt.Errorf("missing user history: %+v", req.Messages)
+			}
+			if len(req.Tools) == 0 {
+				return nil, errors.New("missing tools")
+			}
+			if opts.ToolHandler == nil {
+				return nil, errors.New("missing tool handler")
+			}
+			res := opts.ToolHandler(ctx, ai.ToolCall{
 				ID:    "fake-call-1",
 				Name:  "conformance_echo",
 				Input: map[string]any{"value": "agent-conformance"},
 			})
-			delegate := opts.ToolHandler(ctx, ai.ToolCall{
-				ID:    "fake-delegate-1",
-				Name:  "delegate",
-				Input: map[string]any{"task": "summarize the conformance marker", "to": "blocked-reviewer"},
-			})
-			if plan.Content == "" {
-				return nil, errors.New("empty plan result")
-			}
-			if echo.Content == "" {
+			if res.Content == "" {
 				return nil, errors.New("empty tool result")
 			}
-			if delegate.Refused != ai.RefusedApproval {
-				return nil, fmt.Errorf("delegate refusal = %q, want %q", delegate.Refused, ai.RefusedApproval)
-			}
 			return &ai.Response{
-				Reply:  "planned, called conformance_echo, and handled guarded delegate refusal",
-				Answer: echo.Content + " " + delegate.Content,
-				ToolCalls: []ai.ToolCall{
-					{ID: "fake-plan-1", Name: "plan", Input: map[string]any{}},
-					{ID: "fake-call-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-					{ID: "fake-delegate-1", Name: "delegate", Input: map[string]any{"task": "summarize the conformance marker", "to": "blocked-reviewer"}, Error: delegate.Content},
-				},
+				Reply:     "used conformance_echo",
+				Answer:    res.Content,
+				ToolCalls: []ai.ToolCall{{ID: "fake-call-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: res.Content}},
 			}, nil
 		}
 		defer func() { fakeGen = nil }()
@@ -224,23 +83,15 @@ func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 
 	var sawTool bool
 	var sawRunInfo bool
-	var sawBlockedDelegate bool
 	agentOpts := []Option{
 		Name("conformance-" + provider.name),
 		Provider(provider.name),
 		APIKey(os.Getenv(provider.key)),
-		Prompt(conformanceSystemPrompt(provider.name)),
+		Prompt("You are a conformance test agent. Use the conformance_echo tool exactly once with input {\"value\":\"agent-conformance\"}, then answer with the tool result."),
 		WithRegistry(registry.NewMemoryRegistry()),
 		WithStore(store.NewMemoryStore()),
 		WithMemory(NewInMemory(8)),
 		ModelCallTimeout(45 * time.Second),
-		ApproveTool(func(tool string, input map[string]any) (bool, string) {
-			if tool == "delegate" {
-				sawBlockedDelegate = true
-				return false, "cross-provider conformance blocks delegate side effects"
-			}
-			return true, ""
-		}),
 		WithTool("conformance_echo", "Echo a conformance value and return a deterministic marker.", map[string]any{
 			"value": map[string]any{"type": "string", "description": "value to echo"},
 		}, func(ctx context.Context, input map[string]any) (string, error) {
@@ -266,7 +117,7 @@ func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 	}
 
 	a := New(agentOpts...)
-	resp, err := askWithConformanceRetry(context.Background(), a, "Run the provider conformance check.", &sawTool, &sawBlockedDelegate)
+	resp, err := a.Ask(context.Background(), "Run the provider conformance check.")
 	if err != nil {
 		t.Fatalf("Ask: %v", err)
 	}
@@ -282,175 +133,11 @@ func runAgentConformanceScenario(t *testing.T, provider conformanceProvider) {
 	if !sawRunInfo {
 		t.Fatal("tool did not receive RunInfo")
 	}
-	if !sawBlockedDelegate {
-		t.Fatal("provider did not exercise the guarded delegate path")
-	}
 	if !strings.Contains(resp.Reply, "agent-conformance-ok") && !strings.Contains(resp.Reply, "agent-conformance") {
 		t.Fatalf("reply %q does not include conformance marker", resp.Reply)
 	}
 }
 
-func askWithConformanceRetry(ctx context.Context, a Agent, initialPrompt string, sawTool, sawBlockedDelegate *bool) (*Response, error) {
-	const maxAttempts = 4
-	prompt := initialPrompt
-	var resp *Response
-	for attempt := 1; attempt <= maxAttempts; attempt++ {
-		var err error
-		resp, err = a.Ask(ctx, prompt)
-		if err != nil {
-			return nil, err
-		}
-		sawRequiredTool := sawTool == nil || *sawTool
-		sawRequiredDelegate := sawBlockedDelegate == nil || *sawBlockedDelegate
-		hasMarker := responseHasConformanceMarker(resp)
-		if sawRequiredTool && sawRequiredDelegate && hasMarker {
-			return resp, nil
-		}
-		if attempt == maxAttempts {
-			break
-		}
-		prompt = nextConformanceRetryPrompt(sawRequiredTool, sawRequiredDelegate, hasMarker, attempt+1)
-	}
-	missing := missingConformanceRequirements(sawTool, sawBlockedDelegate, responseHasConformanceMarker(resp))
-	if len(missing) > 0 {
-		return resp, fmt.Errorf("provider conformance incomplete after %d attempts: missing %s", maxAttempts, strings.Join(missing, ", "))
-	}
-	return resp, nil
-}
-
-func askWithConformanceToolRetry(ctx context.Context, a Agent, initialPrompt string, sawTool *bool) (*Response, error) {
-	return askWithConformanceRetry(ctx, a, initialPrompt, sawTool, nil)
-}
-
-func missingConformanceRequirements(sawTool, sawBlockedDelegate *bool, hasMarker bool) []string {
-	var missing []string
-	if sawTool != nil && !*sawTool {
-		missing = append(missing, "conformance_echo")
-	}
-	if sawBlockedDelegate != nil && !*sawBlockedDelegate {
-		missing = append(missing, "guarded delegate")
-	}
-	if !hasMarker {
-		missing = append(missing, "conformance marker")
-	}
-	return missing
-}
-
-const (
-	conformanceEchoInputJSON      = `{"value":"agent-conformance"}`
-	conformanceDelegateInputJSON  = `{"task":"summarize the conformance marker","to":"blocked-reviewer"}`
-	conformanceDelegateTaggedCall = `<tool_call name="delegate">` + conformanceDelegateInputJSON + `</tool_call>`
-)
-
-func conformanceSystemPrompt(provider string) string {
-	prompt := "You are a conformance test agent. Create a short plan, use conformance_echo exactly once with input " + conformanceEchoInputJSON + ", then attempt to delegate a summary to blocked-reviewer with input " + conformanceDelegateInputJSON + ". You must complete both tool calls before any final answer; a final answer that only mentions the steps without calling both tools is invalid. If the delegate is refused, explain the refusal and answer with the echo result."
-	if provider == "atlascloud" {
-		prompt += " AtlasCloud/minimax conformance note: the delegate attempt is mandatory after conformance_echo. If native tool_calls are unavailable, emit the delegate as " + conformanceDelegateTaggedCall + " rather than answering in prose."
-	}
-	return prompt
-}
-
-func TestAgentProviderConformanceAtlasCloudPromptRequiresTaggedDelegateFallback(t *testing.T) {
-	prompt := conformanceSystemPrompt("atlascloud")
-	for _, want := range []string{
-		"delegate attempt is mandatory",
-		"You must complete both tool calls before any final answer",
-		"<tool_call name=\"delegate\">",
-		`{"task":"summarize the conformance marker","to":"blocked-reviewer"}`,
-	} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("atlascloud conformance prompt %q missing %q", prompt, want)
-		}
-	}
-
-	if strings.Contains(conformanceSystemPrompt("openai"), "AtlasCloud/minimax") {
-		t.Fatal("non-AtlasCloud prompt should not include provider-specific fallback guidance")
-	}
-}
-
-func TestAgentProviderConformanceRetryPromptsRequireBothTools(t *testing.T) {
-	for name, prompt := range map[string]string{
-		"missing tool":     nextConformanceRetryPrompt(false, false, false, 2),
-		"missing delegate": nextConformanceRetryPrompt(true, false, true, 2),
-	} {
-		for _, want := range []string{
-			"delegate exactly once",
-			conformanceDelegateTaggedCall,
-			"do not",
-		} {
-			if !strings.Contains(prompt, want) {
-				t.Fatalf("%s retry prompt %q missing %q", name, prompt, want)
-			}
-		}
-	}
-}
-
-func TestAgentProviderConformanceFinalDelegateRetryUsesTaggedCall(t *testing.T) {
-	prompt := nextConformanceRetryPrompt(true, false, true, 4)
-	for _, want := range []string{
-		"Final conformance retry",
-		conformanceDelegateTaggedCall,
-		"agent-conformance-ok",
-	} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("final delegate retry prompt %q missing %q", prompt, want)
-		}
-	}
-}
-
-func TestAgentProviderConformanceMarkerRetryRequiresExactMarkerReply(t *testing.T) {
-	prompt := nextConformanceRetryPrompt(true, true, false, 2)
-	for _, want := range []string{
-		"omitted the conformance marker",
-		"do not call more tools",
-		"do not summarize",
-		"Reply with exactly this sentence: agent-conformance-ok after guarded delegate refusal.",
-	} {
-		if !strings.Contains(prompt, want) {
-			t.Fatalf("marker retry prompt %q missing %q", prompt, want)
-		}
-	}
-}
-
-func nextConformanceRetryPrompt(sawTool, sawBlockedDelegate, hasMarker bool, attempt int) string {
-	if attempt >= 4 && sawTool && !sawBlockedDelegate {
-		return "Final conformance retry: emit exactly this tagged tool call so the harness can execute the guarded delegate refusal, then include agent-conformance-ok and the refusal in the final answer: " + conformanceDelegateTaggedCall
-	}
-	switch {
-	case !sawTool:
-		return "The previous response did not call the required conformance_echo tool. Retry the same conformance check now: first call conformance_echo exactly once with input " + conformanceEchoInputJSON + ", then call delegate exactly once with input " + conformanceDelegateInputJSON + "; do not provide a final answer until both tool calls have been attempted. If native delegate tool_calls are unavailable after conformance_echo, emit exactly " + conformanceDelegateTaggedCall + ". The delegate is expected to be refused by policy; include that refusal and the agent-conformance marker in the final answer."
-	case !sawBlockedDelegate:
-		return "The previous response called conformance_echo but did not attempt the required guarded delegation. Continue the same conformance check now: call delegate exactly once with input " + conformanceDelegateInputJSON + "; do not answer in prose until that delegate call has been attempted. If native tool_calls are unavailable, emit exactly " + conformanceDelegateTaggedCall + ". The delegate is expected to be refused by policy; include that refusal and the agent-conformance marker in the final answer."
-	case !hasMarker:
-		return "The previous response completed the required tool calls but omitted the conformance marker. Continue the same conformance check now: do not call more tools, do not summarize, and do not use synonyms. Reply with exactly this sentence: agent-conformance-ok after guarded delegate refusal."
-	default:
-		return "Retry the provider conformance check and include the agent-conformance marker in the final answer."
-	}
-}
-
-func responseHasConformanceMarker(resp *Response) bool {
-	if resp == nil {
-		return false
-	}
-	return strings.Contains(resp.Reply, "agent-conformance-ok") || strings.Contains(resp.Reply, "agent-conformance")
-}
-
-func validateConformanceRequest(req *ai.Request, opts ai.Options) error {
-	if req.Prompt == "" {
-		return errors.New("missing prompt")
-	}
-	if len(req.Messages) == 0 || req.Messages[len(req.Messages)-1].Role != "user" {
-		return fmt.Errorf("missing user history: %+v", req.Messages)
-	}
-	if len(req.Tools) == 0 {
-		return errors.New("missing tools")
-	}
-	if opts.ToolHandler == nil {
-		return errors.New("missing tool handler")
-	}
-	return nil
-}
-
 func TestAgentProviderConformanceFakeError(t *testing.T) {
 	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
 		return nil, errors.New("conformance provider failure")
@@ -469,339 +156,3 @@ func TestAgentProviderConformanceFakeError(t *testing.T) {
 		t.Fatalf("Ask error = %v, want conformance provider failure", err)
 	}
 }
-
-func TestAgentProviderConformanceRetriesMissingTool(t *testing.T) {
-	var attempts int
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		attempts++
-		if err := validateConformanceRequest(req, opts); err != nil {
-			return nil, err
-		}
-		if attempts == 1 {
-			return &ai.Response{Reply: "I can confirm agent-conformance in prose only."}, nil
-		}
-		echo := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "fake-call-1",
-			Name:  "conformance_echo",
-			Input: map[string]any{"value": "agent-conformance"},
-		})
-		return &ai.Response{
-			Reply:  "called conformance_echo",
-			Answer: echo.Content,
-			ToolCalls: []ai.ToolCall{
-				{ID: "fake-call-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-			},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	a := New(
-		Name("conformance-retry"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := askWithConformanceToolRetry(context.Background(), a, "Run the provider conformance check.", &sawTool)
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if attempts != 2 {
-		t.Fatalf("attempts = %d, want retry after missing tool", attempts)
-	}
-	if !sawTool {
-		t.Fatal("retry did not execute conformance_echo")
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want tool result marker", resp.Reply)
-	}
-}
-
-func TestAgentProviderConformanceRetriesMissingMarker(t *testing.T) {
-	var attempts int
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		attempts++
-		if err := validateConformanceRequest(req, opts); err != nil {
-			return nil, err
-		}
-		if attempts == 1 {
-			return &ai.Response{Reply: "called conformance_echo and handled guarded delegate refusal without the required marker"}, nil
-		}
-		return &ai.Response{Reply: "agent-conformance-ok after guarded delegate refusal"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	sawTool := true
-	sawBlockedDelegate := true
-	a := New(
-		Name("conformance-retry-marker"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := askWithConformanceRetry(context.Background(), a, "Run the provider conformance check.", &sawTool, &sawBlockedDelegate)
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if attempts != 2 {
-		t.Fatalf("attempts = %d, want retry after missing marker", attempts)
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want conformance marker", resp.Reply)
-	}
-}
-
-func TestAgentProviderConformanceRetriesMissingDelegate(t *testing.T) {
-	var attempts int
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		attempts++
-		if err := validateConformanceRequest(req, opts); err != nil {
-			return nil, err
-		}
-		echo := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "fake-call-1",
-			Name:  "conformance_echo",
-			Input: map[string]any{"value": "agent-conformance"},
-		})
-		if attempts == 1 {
-			return &ai.Response{
-				Reply:  "called conformance_echo but skipped delegate",
-				Answer: echo.Content,
-				ToolCalls: []ai.ToolCall{
-					{ID: "fake-call-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-				},
-			}, nil
-		}
-		delegate := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "fake-delegate-1",
-			Name:  "delegate",
-			Input: map[string]any{"task": "summarize the conformance marker", "to": "blocked-reviewer"},
-		})
-		return &ai.Response{
-			Reply:  "called conformance_echo and handled guarded delegate refusal",
-			Answer: echo.Content + " " + delegate.Content,
-			ToolCalls: []ai.ToolCall{
-				{ID: "fake-call-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-				{ID: "fake-delegate-1", Name: "delegate", Input: map[string]any{"task": "summarize the conformance marker", "to": "blocked-reviewer"}, Error: delegate.Content},
-			},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	var sawBlockedDelegate bool
-	a := New(
-		Name("conformance-retry-delegate"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		ApproveTool(func(tool string, input map[string]any) (bool, string) {
-			if tool == "delegate" {
-				sawBlockedDelegate = true
-				return false, "cross-provider conformance blocks delegate side effects"
-			}
-			return true, ""
-		}),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := askWithConformanceRetry(context.Background(), a, "Run the provider conformance check.", &sawTool, &sawBlockedDelegate)
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if attempts != 2 {
-		t.Fatalf("attempts = %d, want retry after missing delegate", attempts)
-	}
-	if !sawBlockedDelegate {
-		t.Fatal("retry did not attempt guarded delegate")
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") && !strings.Contains(resp.Reply, "agent-conformance") {
-		t.Fatalf("Reply = %q, want conformance marker", resp.Reply)
-	}
-}
-
-func TestAgentProviderConformanceFailsWhenDelegateStillMissing(t *testing.T) {
-	var attempts int
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		attempts++
-		if err := validateConformanceRequest(req, opts); err != nil {
-			return nil, err
-		}
-		echo := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    fmt.Sprintf("fake-call-%d", attempts),
-			Name:  "conformance_echo",
-			Input: map[string]any{"value": "agent-conformance"},
-		})
-		return &ai.Response{
-			Reply:  "called conformance_echo with agent-conformance-ok but skipped delegate",
-			Answer: echo.Content,
-			ToolCalls: []ai.ToolCall{
-				{ID: fmt.Sprintf("fake-call-%d", attempts), Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-			},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	var sawBlockedDelegate bool
-	a := New(
-		Name("conformance-retry-delegate-exhausted"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		ApproveTool(func(tool string, input map[string]any) (bool, string) {
-			if tool == "delegate" {
-				sawBlockedDelegate = true
-				return false, "cross-provider conformance blocks delegate side effects"
-			}
-			return true, ""
-		}),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	_, err := askWithConformanceRetry(context.Background(), a, "Run the provider conformance check.", &sawTool, &sawBlockedDelegate)
-	if err == nil || !strings.Contains(err.Error(), "guarded delegate") {
-		t.Fatalf("Ask error = %v, want missing guarded delegate", err)
-	}
-	if attempts != 4 {
-		t.Fatalf("attempts = %d, want retries through max attempts", attempts)
-	}
-}
-
-func TestAgentExecutesProviderTextToolCallFallback(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			return nil, errors.New("missing tool handler")
-		}
-		return &ai.Response{
-			Reply: `{"name":"conformance_echo","input":{"value":"agent-conformance"}}`,
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	a := New(
-		Name("conformance-text-tool"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			if input["value"] != "agent-conformance" {
-				return "", fmt.Errorf("unexpected value %v", input["value"])
-			}
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := a.Ask(context.Background(), "Run the text tool call fallback.")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if !sawTool {
-		t.Fatal("text tool call fallback did not execute the tool")
-	}
-	if len(resp.ToolCalls) != 1 || resp.ToolCalls[0].Name != "conformance_echo" {
-		t.Fatalf("ToolCalls = %+v, want conformance_echo", resp.ToolCalls)
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want tool result marker", resp.Reply)
-	}
-	if strings.Contains(resp.Reply, `"name":"conformance_echo"`) {
-		t.Fatalf("Reply = %q, want tool result instead of raw JSON", resp.Reply)
-	}
-}
-
-func TestAgentExecutesTextToolCallFallbackAfterStructuredToolCall(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			return nil, errors.New("missing tool handler")
-		}
-		echo := opts.ToolHandler(ctx, ai.ToolCall{
-			ID:    "structured-echo-1",
-			Name:  "conformance_echo",
-			Input: map[string]any{"value": "agent-conformance"},
-		})
-		return &ai.Response{
-			Reply:  echo.Content + "\n<tool_call name=\"delegate\">{\"task\":\"summarize the conformance marker\",\"to\":\"blocked-reviewer\"}</tool_call>",
-			Answer: echo.Content,
-			ToolCalls: []ai.ToolCall{
-				{ID: "structured-echo-1", Name: "conformance_echo", Input: map[string]any{"value": "agent-conformance"}, Result: echo.Content},
-			},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	var sawTool bool
-	var sawBlockedDelegate bool
-	a := New(
-		Name("conformance-mixed-text-tool"),
-		Provider("fake"),
-		WithRegistry(registry.NewMemoryRegistry()),
-		WithStore(store.NewMemoryStore()),
-		WithMemory(NewInMemory(4)),
-		ApproveTool(func(tool string, input map[string]any) (bool, string) {
-			if tool == "delegate" {
-				sawBlockedDelegate = true
-				return false, "cross-provider conformance blocks delegate side effects"
-			}
-			return true, ""
-		}),
-		WithTool("conformance_echo", "Echo a conformance value.", map[string]any{
-			"value": map[string]any{"type": "string"},
-		}, func(ctx context.Context, input map[string]any) (string, error) {
-			sawTool = true
-			return `{"marker":"agent-conformance-ok"}`, nil
-		}),
-	)
-
-	resp, err := a.Ask(context.Background(), "Run the mixed structured/text tool fallback.")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if !sawTool {
-		t.Fatal("structured conformance_echo did not execute")
-	}
-	if !sawBlockedDelegate {
-		t.Fatal("tagged text delegate fallback did not execute")
-	}
-	if len(resp.ToolCalls) != 2 {
-		t.Fatalf("ToolCalls = %+v, want structured echo and text delegate", resp.ToolCalls)
-	}
-	if resp.ToolCalls[1].Name != "delegate" || resp.ToolCalls[1].Error != ai.RefusedApproval {
-		t.Fatalf("delegate ToolCall = %+v, want refused delegate", resp.ToolCalls[1])
-	}
-	if !strings.Contains(resp.Reply, "agent-conformance-ok") {
-		t.Fatalf("Reply = %q, want conformance marker", resp.Reply)
-	}
-}

agent/integration_test.go

@@ -2,7 +2,6 @@ package agent
 
 import (
 	"context"
-	"io"
 	"strings"
 	"testing"
 
@@ -17,7 +16,6 @@ import (
 // it with a deferred cleanup. Tests in this package are not parallel,
 // so a package-level hook is safe.
 var fakeGen func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error)
-var fakeStream func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error)
 
 type fakeModel struct{ opts ai.Options }
 
@@ -35,33 +33,10 @@ func (m *fakeModel) Generate(ctx context.Context, req *ai.Request, _ ...ai.Gener
 	return &ai.Response{Reply: "ok"}, nil
 }
 func (m *fakeModel) Stream(ctx context.Context, req *ai.Request, _ ...ai.GenerateOption) (ai.Stream, error) {
-	if fakeStream != nil {
-		return fakeStream(ctx, m.opts, req)
-	}
-	return &sliceStream{chunks: []string{"ok"}}, nil
+	return nil, nil
 }
 func (m *fakeModel) String() string { return "fake" }
 
-type sliceStream struct {
-	chunks []string
-	idx    int
-	closed bool
-}
-
-func (s *sliceStream) Recv() (*ai.Response, error) {
-	if s.idx >= len(s.chunks) {
-		return nil, io.EOF
-	}
-	chunk := s.chunks[s.idx]
-	s.idx++
-	return &ai.Response{Reply: chunk}, nil
-}
-
-func (s *sliceStream) Close() error {
-	s.closed = true
-	return nil
-}
-
 func init() {
 	ai.Register("fake", func(opts ...ai.Option) ai.Model {
 		m := &fakeModel{}

agent/memory.go

@@ -24,12 +24,6 @@ type Memory interface {
 	Clear()
 }
 
-// MemorySummaryFunc turns older conversation messages into a compact
-// replacement message for active context. It is called while the default
-// memory is locked, so implementations should be deterministic and avoid
-// calling back into the same memory instance.
-type MemorySummaryFunc func([]ai.Message) ai.Message
-
 // MemoryCompaction configures deterministic, store-backed context compaction
 // for the default memory implementation. When the retained conversation grows
 // past MaxMessages, older turns are collapsed into a summary message while the
@@ -37,7 +31,6 @@ type MemorySummaryFunc func([]ai.Message) ai.Message
 type MemoryCompaction struct {
 	MaxMessages int
 	KeepRecent  int
-	Summarize   MemorySummaryFunc
 }
 
 // MemoryRecall is implemented by memory backends that can retrieve durable
@@ -56,29 +49,11 @@ func NewMemory(s store.Store, key string, limit int) Memory {
 	return m
 }
 
-// NewRetrievalMemory returns store-backed memory that keeps a bounded active
-// conversation and archives every turn for retrieval. It is useful when callers
-// want relevant durable recall without summary compaction in the active context.
-// A nil store or empty key keeps only the active in-process buffer.
-func NewRetrievalMemory(s store.Store, key string, activeLimit int) Memory {
-	m := &storeMemory{store: s, key: key, hist: ai.NewHistory(activeLimit), retrieveAll: true}
-	m.load()
-	return m
-}
-
 // NewCompactingMemory returns store-backed memory with explicit compaction and
 // retrieval controls. It keeps all messages in the backing store, compacts older
 // turns into a deterministic summary when the conversation exceeds maxMessages,
 // and lets callers recall relevant prior turns with Recall.
 func NewCompactingMemory(s store.Store, key string, maxMessages, keepRecent int) Memory {
-	return NewCompactingMemoryWithOptions(s, key, MemoryCompaction{MaxMessages: maxMessages, KeepRecent: keepRecent})
-}
-
-// NewCompactingMemoryWithOptions returns store-backed memory configured with
-// explicit compaction options, including an optional summarization hook.
-func NewCompactingMemoryWithOptions(s store.Store, key string, compaction MemoryCompaction) Memory {
-	maxMessages := compaction.MaxMessages
-	keepRecent := compaction.KeepRecent
 	if keepRecent <= 0 {
 		keepRecent = maxMessages / 2
 	}
@@ -94,7 +69,6 @@ func NewCompactingMemoryWithOptions(s store.Store, key string, compaction Memory
 		compaction: MemoryCompaction{
 			MaxMessages: maxMessages,
 			KeepRecent:  keepRecent,
-			Summarize:   compaction.Summarize,
 		},
 	}
 	m.load()
@@ -110,20 +84,16 @@ func NewInMemory(limit int) Memory {
 // storeMemory is the default Memory: an ai.History buffer optionally
 // persisted to a store.
 type storeMemory struct {
-	mu          sync.Mutex
-	store       store.Store
-	key         string
-	hist        *ai.History
-	compaction  MemoryCompaction
-	archive     []ai.Message
-	retrieveAll bool
+	mu         sync.Mutex
+	store      store.Store
+	key        string
+	hist       *ai.History
+	compaction MemoryCompaction
+	archive    []ai.Message
 }
 
 func (m *storeMemory) Add(role, content string) {
 	m.mu.Lock()
-	if m.retrieveAll {
-		m.archive = append(m.archive, ai.Message{Role: role, Content: content})
-	}
 	m.hist.Add(role, content)
 	m.mu.Unlock()
 	m.compact()
@@ -147,8 +117,6 @@ func (m *storeMemory) Clear() {
 // Recall returns archived messages whose content contains words from query.
 // It is deterministic and provider-neutral: no embeddings or model calls are
 // required, but semantic/vector stores can replace Memory for richer retrieval.
-// When created with NewRetrievalMemory the archive contains every persisted
-// turn; when created with NewCompactingMemory it contains compacted older turns.
 func (m *storeMemory) Recall(query string, limit int) []ai.Message {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -202,9 +170,6 @@ func (m *storeMemory) load() {
 	}
 	m.mu.Lock()
 	m.archive = state.Archive
-	if m.retrieveAll && len(m.archive) == 0 {
-		m.archive = append(m.archive, state.Messages...)
-	}
 	for _, msg := range state.Messages {
 		m.hist.Add(msg.Role, msg.Content)
 	}
@@ -248,13 +213,9 @@ func (m *storeMemory) compact() {
 	older := msgs[:cut]
 	recent := msgs[cut:]
 	m.archive = append(m.archive, older...)
-	summarize := m.compaction.Summarize
-	if summarize == nil {
-		summarize = defaultMemorySummary
-	}
-	summary := summarize(older)
-	if summary.Role == "" {
-		summary.Role = "system"
+	summary := ai.Message{
+		Role:    "system",
+		Content: fmt.Sprintf("Conversation memory summary: %s", summarizeMessages(older)),
 	}
 	m.hist.Reset()
 	m.hist.Add(summary.Role, summary.Content)
@@ -263,13 +224,6 @@ func (m *storeMemory) compact() {
 	}
 }
 
-func defaultMemorySummary(msgs []ai.Message) ai.Message {
-	return ai.Message{
-		Role:    "system",
-		Content: fmt.Sprintf("Conversation memory summary: %s", summarizeMessages(msgs)),
-	}
-}
-
 func summarizeMessages(msgs []ai.Message) string {
 	var b strings.Builder
 	for i, msg := range msgs {

agent/memory_test.go

@@ -3,11 +3,9 @@ package agent
 import (
 	"context"
 	"errors"
-	"strconv"
 	"strings"
 	"testing"
 
-	"go-micro.dev/v6/ai"
 	"go-micro.dev/v6/registry"
 	"go-micro.dev/v6/store"
 )
@@ -64,49 +62,6 @@ func TestWithMemoryUsed(t *testing.T) {
 	}
 }
 
-func TestRetrievalMemoryArchivesAllTurnsAndRanksRelevant(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewRetrievalMemory(st, "agent/retrieval/history", 2)
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta owner is lee")
-	m.Add("assistant", "tracked")
-	m.Add("user", "alpha owner is sam")
-
-	if got := len(m.Messages()); got != 2 {
-		t.Fatalf("active messages = %d, want bounded history of 2", got)
-	}
-
-	recall, ok := m.(MemoryRecall)
-	if !ok {
-		t.Fatal("retrieval memory should support recall")
-	}
-	recalled := recall.Recall("alpha budget", 2)
-	if len(recalled) == 0 {
-		t.Fatal("expected relevant recalled turns")
-	}
-	if got := recalled[0].Content.(string); !strings.Contains(got, "alpha budget is 42") {
-		t.Fatalf("top recall = %q, want archived alpha budget turn", got)
-	}
-}
-
-func TestRetrievalMemoryPersistsArchiveAcrossReload(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewRetrievalMemory(st, "agent/retrieval/reload", 1)
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta budget is 7")
-
-	reloaded := NewRetrievalMemory(st, "agent/retrieval/reload", 1)
-	recalled := reloaded.(MemoryRecall).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)
-	}
-}
-
 func TestCompactingMemoryRecallRanksSpecificMatches(t *testing.T) {
 	m := NewCompactingMemory(store.NewMemoryStore(), "agent/rank/history", 3, 1).(MemoryRecall)
 	writer := m.(Memory)
@@ -147,36 +102,6 @@ func TestCompactingMemoryArchivePersistsAndReloads(t *testing.T) {
 	}
 }
 
-func TestCompactingMemoryUsesCustomSummarizerAndReloadsRecall(t *testing.T) {
-	st := store.NewMemoryStore()
-	m := NewCompactingMemoryWithOptions(st, "agent/custom/history", MemoryCompaction{
-		MaxMessages: 3,
-		KeepRecent:  1,
-		Summarize: func(msgs []ai.Message) ai.Message {
-			return ai.Message{Role: "system", Content: "custom summary count=" + strconv.Itoa(len(msgs))}
-		},
-	})
-	m.Add("user", "alpha budget is 42")
-	m.Add("assistant", "noted")
-	m.Add("user", "beta budget is 7")
-	m.Add("assistant", "noted")
-
-	msgs := m.Messages()
-	if len(msgs) == 0 || msgs[0].Content != "custom summary count=3" {
-		t.Fatalf("summary = %#v, want custom summarizer output", msgs)
-	}
-
-	reloaded := NewCompactingMemoryWithOptions(st, "agent/custom/history", MemoryCompaction{MaxMessages: 3, KeepRecent: 1})
-	recall := reloaded.(MemoryRecall)
-	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

agent/options.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/broker"
 	"go-micro.dev/v6/client"
 	"go-micro.dev/v6/flow"
 	"go-micro.dev/v6/registry"
@@ -41,11 +40,9 @@ type Options struct {
 	Provider     string
 	Model        string
 	APIKey       string
-	BaseURL      string
 	Address      string
 	Registry     registry.Registry
 	Client       client.Client
-	Broker       broker.Broker
 	Store        store.Store
 	HistoryLimit int
 
@@ -59,23 +56,10 @@ type Options struct {
 	// ModelRetryBackoff is the base delay between transient provider failures
 	// (grows exponentially per attempt when retries are enabled).
 	ModelRetryBackoff time.Duration
-	// ToolTimeout bounds each tool execution (0 disables). The timeout is
-	// applied before custom tools, delegate, and service RPC calls so context
-	// deadlines propagate consistently through the agent loop.
-	ToolTimeout time.Duration
-	// ToolMaxAttempts bounds tool execution attempts including the first call.
-	// Default 1; retries are opt-in because tools can have side effects.
-	ToolMaxAttempts int
-	// ToolRetryBackoff is the base delay between transient tool failures.
-	ToolRetryBackoff time.Duration
 
 	// Memory is the agent's conversation memory. Nil = the default
 	// store-backed memory (durable across restarts).
 	Memory Memory
-	// MemoryRetrievalLimit enables retrieval-backed default memory without
-	// compaction. The active conversation stays bounded to this many messages
-	// while every turn is archived for deterministic recall.
-	MemoryRetrievalLimit int
 	// MemoryCompaction enables deterministic compaction/retrieval on the
 	// default store-backed memory. Custom Memory implementations can expose
 	// retrieval by implementing MemoryRecall.
@@ -107,11 +91,6 @@ type Options struct {
 	// and tool calls. Nil disables instrumentation.
 	TraceProvider trace.TracerProvider
 
-	// TraceInputs controls whether agent observability records include raw
-	// user messages. It is false by default so spans and persisted run
-	// timelines carry correlation and shape without leaking prompts.
-	TraceInputs bool
-
 	// tools are developer-registered custom tools (see WithTool).
 	tools []customTool
 	// wrappers are developer-registered tool-execution wrappers
@@ -128,9 +107,6 @@ func newOptions(opts ...Option) Options {
 		ModelTimeout:      30 * time.Second,
 		ModelMaxAttempts:  1, // retries opt-in via ModelRetry (see field doc)
 		ModelRetryBackoff: 100 * time.Millisecond,
-		ToolTimeout:       30 * time.Second,
-		ToolMaxAttempts:   1,
-		ToolRetryBackoff:  100 * time.Millisecond,
 		// On by default and lenient: identical repeated calls are a
 		// no-progress loop, never useful. Set LoopLimit(0) to disable.
 		LoopLimit: 3,
@@ -171,12 +147,6 @@ func APIKey(k string) Option {
 	return func(o *Options) { o.APIKey = k }
 }
 
-// BaseURL sets the base URL for the LLM provider. Use this to point
-// the provider at a non-default endpoint (e.g., local Ollama, a proxy).
-func BaseURL(url string) Option {
-	return func(o *Options) { o.BaseURL = url }
-}
-
 // Address sets the network address for the agent's service endpoint.
 // Use "127.0.0.1:0" in local harnesses/tests to bind an ephemeral loopback
 // port and avoid advertising the default service address.
@@ -194,13 +164,6 @@ func WithClient(c client.Client) Option {
 	return func(o *Options) { o.Client = c }
 }
 
-// WithBroker sets the broker used by the agent service endpoint. Use an
-// in-memory broker in local harnesses/tests to avoid sharing the package-wide
-// default broker listener across concurrently running examples.
-func WithBroker(b broker.Broker) Option {
-	return func(o *Options) { o.Broker = b }
-}
-
 // WithStore sets the store for agent memory.
 func WithStore(s store.Store) Option {
 	return func(o *Options) { o.Store = s }
@@ -236,14 +199,6 @@ func ModelCallTimeout(d time.Duration) Option {
 	return func(o *Options) { o.ModelTimeout = d }
 }
 
-// ToolCallTimeout sets the timeout for each tool execution. It bounds custom
-// tools, built-in delegate calls, and service RPC tools with the same context
-// deadline so mid-run cancellation and slow tools produce safe error results
-// instead of unbounded agent runs. Set 0 to disable.
-func ToolCallTimeout(d time.Duration) Option {
-	return func(o *Options) { o.ToolTimeout = d }
-}
-
 // ModelRetry sets the provider retry budget and backoff for transient failures.
 func ModelRetry(maxAttempts int, backoff time.Duration) Option {
 	return func(o *Options) {
@@ -252,16 +207,6 @@ func ModelRetry(maxAttempts int, backoff time.Duration) Option {
 	}
 }
 
-// ToolRetry sets the tool retry budget and backoff for transient failures.
-// Attempts include the first call. Retries are opt-in because tools may have
-// side effects; keep handlers idempotent before enabling this.
-func ToolRetry(maxAttempts int, backoff time.Duration) Option {
-	return func(o *Options) {
-		o.ToolMaxAttempts = maxAttempts
-		o.ToolRetryBackoff = backoff
-	}
-}
-
 // WithA2A makes Run serve the agent over the A2A protocol on addr (e.g.
 // ":4000"), so other agents can reach it directly by URL without a
 // separate gateway. The agent stays a normal go-micro service as well;
@@ -277,40 +222,19 @@ func WithMemory(m Memory) Option {
 	return func(o *Options) { o.Memory = m }
 }
 
-// RetrievalMemory enables deterministic, store-backed retrieval memory for
-// the default agent memory without compaction. Active context is capped at
-// activeLimit messages while every turn is archived in the store for Recall.
-func RetrievalMemory(activeLimit int) Option {
-	return func(o *Options) {
-		o.MemoryRetrievalLimit = activeLimit
-		if o.MemoryRecallLimit == 0 {
-			o.MemoryRecallLimit = 5
-		}
-	}
-}
-
 // CompactMemory enables deterministic, store-backed memory compaction for the
 // default agent memory. Older turns are summarized once active context exceeds
 // maxMessages, keepRecent newest turns remain verbatim, and recalled archived
 // turns are injected into matching future asks.
 func CompactMemory(maxMessages, keepRecent int) Option {
 	return func(o *Options) {
-		o.MemoryCompaction.MaxMessages = maxMessages
-		o.MemoryCompaction.KeepRecent = keepRecent
+		o.MemoryCompaction = MemoryCompaction{MaxMessages: maxMessages, KeepRecent: keepRecent}
 		if o.MemoryRecallLimit == 0 {
 			o.MemoryRecallLimit = 5
 		}
 	}
 }
 
-// MemorySummarizer sets the deterministic summarization hook used by the
-// default compacting memory. It is optional; without it, compacted memory uses
-// a provider-neutral text summary. The hook receives the older messages being
-// removed from active context and returns the replacement summary message.
-func MemorySummarizer(fn MemorySummaryFunc) Option {
-	return func(o *Options) { o.MemoryCompaction.Summarize = fn }
-}
-
 // MemoryRecallLimit sets how many archived turns a memory backend may inject
 // into a model request for the current Ask. Use 0 to disable retrieval.
 func MemoryRecallLimit(n int) Option {
@@ -371,11 +295,3 @@ func WithTool(name, description string, properties map[string]any, handler ToolF
 func TraceProvider(tp trace.TracerProvider) Option {
 	return func(o *Options) { o.TraceProvider = tp }
 }
-
-// TraceInputs opts in to recording raw user messages on agent run events.
-// By default inputs are redacted from OpenTelemetry spans and persisted run
-// timelines; use this only when the observability backend is approved to store
-// prompt content.
-func TraceInputs(enabled bool) Option {
-	return func(o *Options) { o.TraceInputs = enabled }
-}

agent/otel.go

@@ -3,9 +3,7 @@ package agent
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"sort"
 	"strings"
 	"time"
@@ -20,59 +18,40 @@ import (
 const agentInstrumentationName = "go-micro.dev/v6/agent"
 
 const (
-	spanNameRun         = "agent.run"
-	spanNameModelCall   = "agent.model.call"
-	spanNameModelStream = "agent.model.stream"
-	spanNameToolCall    = "agent.tool.call"
+	spanNameRun       = "agent.run"
+	spanNameModelCall = "agent.model.call"
+	spanNameToolCall  = "agent.tool.call"
 
-	AttrRunID            = "agent.run.id"
-	AttrParentRunID      = "agent.run.parent_id"
-	AttrAgentName        = "agent.name"
-	AttrProvider         = "agent.model.provider"
-	AttrModel            = "agent.model.name"
-	AttrLatencyMS        = "agent.latency_ms"
-	AttrInputTokens      = "agent.tokens.input"
-	AttrOutputTokens     = "agent.tokens.output"
-	AttrTotalTokens      = "agent.tokens.total"
-	AttrAttempt          = "agent.model.attempt"
-	AttrMaxAttempts      = "agent.model.max_attempts"
-	AttrToolAttempt      = "agent.tool.attempt"
-	AttrToolMaxAttempts  = "agent.tool.max_attempts"
-	AttrToolName         = "agent.tool.name"
-	AttrDelegate         = "agent.delegate"
-	AttrGuardrailBlock   = "agent.guardrail.block"
-	AttrRefusal          = "agent.refusal"
-	AttrInputChars       = "agent.input.chars"
-	AttrErrorKind        = "agent.error.kind"
-	AttrCheckpointStatus = "agent.checkpoint.status"
-	AttrCheckpointStage  = "agent.checkpoint.stage"
-	AttrFlowName         = "agent.flow.name"
-	AttrFlowStep         = "agent.flow.step"
-	AttrDispatch         = "agent.dispatch"
-	AttrTrigger          = "agent.trigger"
-	AttrRunEventKind     = "agent.event.kind"
+	AttrRunID          = "agent.run.id"
+	AttrParentRunID    = "agent.run.parent_id"
+	AttrAgentName      = "agent.name"
+	AttrProvider       = "agent.model.provider"
+	AttrModel          = "agent.model.name"
+	AttrLatencyMS      = "agent.latency_ms"
+	AttrInputTokens    = "agent.tokens.input"
+	AttrOutputTokens   = "agent.tokens.output"
+	AttrTotalTokens    = "agent.tokens.total"
+	AttrToolName       = "agent.tool.name"
+	AttrDelegate       = "agent.delegate"
+	AttrGuardrailBlock = "agent.guardrail.block"
+	AttrRefusal        = "agent.refusal"
 )
 
 type RunEvent struct {
-	Time        time.Time `json:"time"`
-	RunID       string    `json:"run_id"`
-	ParentID    string    `json:"parent_id,omitempty"`
-	TraceID     string    `json:"trace_id,omitempty"`
-	SpanID      string    `json:"span_id,omitempty"`
-	Agent       string    `json:"agent"`
-	Kind        string    `json:"kind"`
-	Name        string    `json:"name,omitempty"`
-	Provider    string    `json:"provider,omitempty"`
-	Model       string    `json:"model,omitempty"`
-	Attempt     int       `json:"attempt,omitempty"`
-	MaxAttempts int       `json:"max_attempts,omitempty"`
-	LatencyMS   int64     `json:"latency_ms,omitempty"`
-	Tokens      Usage     `json:"tokens,omitempty"`
-	Refused     string    `json:"refused,omitempty"`
-	Status      string    `json:"status,omitempty"`
-	Error       string    `json:"error,omitempty"`
-	ErrorKind   string    `json:"error_kind,omitempty"`
-	InputChars  int       `json:"input_chars,omitempty"`
+	Time      time.Time `json:"time"`
+	RunID     string    `json:"run_id"`
+	ParentID  string    `json:"parent_id,omitempty"`
+	TraceID   string    `json:"trace_id,omitempty"`
+	SpanID    string    `json:"span_id,omitempty"`
+	Agent     string    `json:"agent"`
+	Kind      string    `json:"kind"`
+	Name      string    `json:"name,omitempty"`
+	Provider  string    `json:"provider,omitempty"`
+	Model     string    `json:"model,omitempty"`
+	LatencyMS int64     `json:"latency_ms,omitempty"`
+	Tokens    Usage     `json:"tokens,omitempty"`
+	Refused   string    `json:"refused,omitempty"`
+	Error     string    `json:"error,omitempty"`
 }
 
 type Usage = ai.Usage
@@ -81,8 +60,7 @@ type Usage = ai.Usage
 // Zero values preserve the full deterministic run list.
 type RunListOptions struct {
 	// Status, when set, keeps only runs with the matching status
-	// (for example "running", "done", "canceled", "timeout",
-	// "rate_limited", "error", or "refused").
+	// (for example "running", "done", "error", or "refused").
 	Status string
 	// TraceID, when set, keeps only runs correlated with this trace id.
 	// A prefix is accepted so operators can paste the shortened trace id
@@ -95,21 +73,18 @@ type RunListOptions struct {
 
 // RunSummary is a compact index entry for a recorded agent run.
 type RunSummary struct {
-	RunID         string    `json:"run_id"`
-	Agent         string    `json:"agent"`
-	ParentID      string    `json:"parent_id,omitempty"`
-	TraceID       string    `json:"trace_id,omitempty"`
-	SpanID        string    `json:"span_id,omitempty"`
-	StartedAt     time.Time `json:"started_at"`
-	UpdatedAt     time.Time `json:"updated_at"`
-	DurationMS    int64     `json:"duration_ms,omitempty"`
-	Events        int       `json:"events"`
-	Status        string    `json:"status,omitempty"`
-	Checkpoint    string    `json:"checkpoint,omitempty"`
-	Stage         string    `json:"stage,omitempty"`
-	LastKind      string    `json:"last_kind,omitempty"`
-	LastError     string    `json:"last_error,omitempty"`
-	LastErrorKind string    `json:"last_error_kind,omitempty"`
+	RunID      string    `json:"run_id"`
+	Agent      string    `json:"agent"`
+	ParentID   string    `json:"parent_id,omitempty"`
+	TraceID    string    `json:"trace_id,omitempty"`
+	SpanID     string    `json:"span_id,omitempty"`
+	StartedAt  time.Time `json:"started_at"`
+	UpdatedAt  time.Time `json:"updated_at"`
+	DurationMS int64     `json:"duration_ms,omitempty"`
+	Events     int       `json:"events"`
+	Status     string    `json:"status,omitempty"`
+	LastKind   string    `json:"last_kind,omitempty"`
+	LastError  string    `json:"last_error,omitempty"`
 }
 
 func (a *agentImpl) tracer() trace.Tracer {
@@ -119,38 +94,29 @@ func (a *agentImpl) tracer() trace.Tracer {
 func (a *agentImpl) startRun(ctx context.Context, message string) (context.Context, func(error)) {
 	info, _ := ai.RunInfoFrom(ctx)
 	start := time.Now()
-	runEvent := RunEvent{Time: start, RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "run", InputChars: len(message)}
-	if a.opts.TraceInputs {
-		runEvent.Name = message
-	}
 
 	if a.opts.TraceProvider == nil {
-		a.recordRunEvent(runEvent)
+		a.recordRunEvent(RunEvent{Time: start, RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "run", Name: message})
 		return ctx, func(err error) {
 			latency := time.Since(start).Milliseconds()
 			if err != nil {
-				a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "error", LatencyMS: latency, Error: err.Error(), ErrorKind: string(ai.ClassifyError(err))})
+				a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "error", LatencyMS: latency, Error: err.Error()})
 				return
 			}
 			a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "done", LatencyMS: latency})
 		}
 	}
 
-	attrs := appendRunInfoAttributes([]attribute.KeyValue{
-		attribute.String(AttrRunID, info.RunID),
-		attribute.String(AttrParentRunID, info.ParentID),
-		attribute.String(AttrAgentName, info.Agent),
-	}, info)
-	ctx, span := a.tracer().Start(ctx, spanNameRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(attrs...))
-	a.recordSpanEvent(span, runEvent)
+	ctx, span := a.tracer().Start(ctx, spanNameRun, trace.WithSpanKind(trace.SpanKindInternal), trace.WithAttributes(
+		attribute.String(AttrRunID, info.RunID), attribute.String(AttrParentRunID, info.ParentID), attribute.String(AttrAgentName, info.Agent)))
+	a.recordSpanEvent(span, RunEvent{Time: start, RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "run", Name: message})
 	return ctx, func(err error) {
 		latency := time.Since(start).Milliseconds()
 		span.SetAttributes(attribute.Int64(AttrLatencyMS, latency))
 		if err != nil {
-			span.SetAttributes(attribute.String(AttrErrorKind, string(ai.ClassifyError(err))))
 			span.RecordError(err)
 			span.SetStatus(codes.Error, err.Error())
-			a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "error", LatencyMS: latency, Error: err.Error(), ErrorKind: string(ai.ClassifyError(err))})
+			a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "error", LatencyMS: latency, Error: err.Error()})
 		} else {
 			span.SetStatus(codes.Ok, "")
 			a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "done", LatencyMS: latency})
@@ -178,32 +144,24 @@ func (m *tracedModel) Generate(ctx context.Context, req *ai.Request, opts ...ai.
 		if resp != nil {
 			usage = resp.Usage
 		}
-		e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, Attempt: info.Attempt, MaxAttempts: info.MaxAttempts, LatencyMS: dur, Tokens: usage}
+		e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, LatencyMS: dur, Tokens: usage}
 		if err != nil {
 			e.Error = err.Error()
-			e.ErrorKind = string(ai.ClassifyError(err))
 		}
 		m.a.recordRunEvent(e)
 		return resp, err
 	}
 
-	attrs := appendRunInfoAttributes([]attribute.KeyValue{
+	ctx, span := m.a.tracer().Start(ctx, spanNameModelCall, trace.WithAttributes(
 		attribute.String(AttrRunID, info.RunID),
 		attribute.String(AttrParentRunID, info.ParentID),
 		attribute.String(AttrAgentName, info.Agent),
 		attribute.String(AttrProvider, provider),
 		attribute.String(AttrModel, model),
-	}, info)
-	ctx, span := m.a.tracer().Start(ctx, spanNameModelCall, trace.WithAttributes(attrs...))
+	))
 	resp, err := m.Model.Generate(ctx, req, opts...)
 	dur := time.Since(start).Milliseconds()
-	attrs = []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
-	if info.Attempt > 0 {
-		attrs = append(attrs, attribute.Int(AttrAttempt, info.Attempt))
-	}
-	if info.MaxAttempts > 0 {
-		attrs = append(attrs, attribute.Int(AttrMaxAttempts, info.MaxAttempts))
-	}
+	attrs := []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
 	usage := ai.Usage{}
 	if resp != nil {
 		usage = resp.Usage
@@ -211,139 +169,20 @@ func (m *tracedModel) Generate(ctx context.Context, req *ai.Request, opts ...ai.
 	}
 	span.SetAttributes(attrs...)
 	if err != nil {
-		span.SetAttributes(attribute.String(AttrErrorKind, string(ai.ClassifyError(err))))
 		span.RecordError(err)
 		span.SetStatus(codes.Error, err.Error())
 	} else {
 		span.SetStatus(codes.Ok, "")
 	}
-	e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, Attempt: info.Attempt, MaxAttempts: info.MaxAttempts, LatencyMS: dur, Tokens: usage}
+	span.End()
+	e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "model", Provider: provider, Model: model, LatencyMS: dur, Tokens: usage}
 	if err != nil {
 		e.Error = err.Error()
-		e.ErrorKind = string(ai.ClassifyError(err))
 	}
 	m.a.recordSpanEvent(span, e)
-	span.End()
 	return resp, err
 }
 
-func (m *tracedModel) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	info, _ := ai.RunInfoFrom(ctx)
-	provider := m.String()
-	model := m.Options().Model
-	start := time.Now()
-
-	if m.a.opts.TraceProvider == nil {
-		stream, err := m.Model.Stream(ctx, req, opts...)
-		if err != nil {
-			m.a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "stream", Provider: provider, Model: model, Attempt: info.Attempt, MaxAttempts: info.MaxAttempts, LatencyMS: time.Since(start).Milliseconds(), Error: err.Error(), ErrorKind: string(ai.ClassifyError(err))})
-			return nil, err
-		}
-		return &tracedStream{Stream: stream, a: m.a, info: info, provider: provider, model: model, start: start}, nil
-	}
-
-	attrs := appendRunInfoAttributes([]attribute.KeyValue{
-		attribute.String(AttrRunID, info.RunID),
-		attribute.String(AttrParentRunID, info.ParentID),
-		attribute.String(AttrAgentName, info.Agent),
-		attribute.String(AttrProvider, provider),
-		attribute.String(AttrModel, model),
-	}, info)
-	ctx, span := m.a.tracer().Start(ctx, spanNameModelStream, trace.WithAttributes(attrs...))
-	stream, err := m.Model.Stream(ctx, req, opts...)
-	if err != nil {
-		dur := time.Since(start).Milliseconds()
-		span.SetAttributes(attribute.Int64(AttrLatencyMS, dur), attribute.String(AttrErrorKind, string(ai.ClassifyError(err))))
-		span.RecordError(err)
-		span.SetStatus(codes.Error, err.Error())
-		e := RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "stream", Provider: provider, Model: model, Attempt: info.Attempt, MaxAttempts: info.MaxAttempts, LatencyMS: dur, Error: err.Error(), ErrorKind: string(ai.ClassifyError(err))}
-		m.a.recordSpanEvent(span, e)
-		span.End()
-		return nil, err
-	}
-	return &tracedStream{Stream: stream, a: m.a, info: info, provider: provider, model: model, start: start, span: span}, nil
-}
-
-type tracedStream struct {
-	ai.Stream
-	a        *agentImpl
-	info     ai.RunInfo
-	provider string
-	model    string
-	start    time.Time
-	span     trace.Span
-	usage    ai.Usage
-	closed   bool
-}
-
-func (s *tracedStream) Recv() (*ai.Response, error) {
-	resp, err := s.Stream.Recv()
-	if resp != nil {
-		s.usage = mergeUsage(s.usage, resp.Usage)
-	}
-	if err != nil {
-		if errors.Is(err, io.EOF) {
-			s.finish(nil)
-		} else {
-			s.finish(err)
-		}
-	}
-	return resp, err
-}
-
-func (s *tracedStream) Close() error {
-	err := s.Stream.Close()
-	s.finish(err)
-	return err
-}
-
-func (s *tracedStream) finish(err error) {
-	if s.closed {
-		return
-	}
-	s.closed = true
-	dur := time.Since(s.start).Milliseconds()
-	e := RunEvent{Time: time.Now(), RunID: s.info.RunID, ParentID: s.info.ParentID, Agent: s.info.Agent, Kind: "stream", Provider: s.provider, Model: s.model, Attempt: s.info.Attempt, MaxAttempts: s.info.MaxAttempts, LatencyMS: dur, Tokens: s.usage}
-	if err != nil {
-		e.Error = err.Error()
-		e.ErrorKind = string(ai.ClassifyError(err))
-	}
-	if s.span == nil {
-		s.a.recordRunEvent(e)
-		return
-	}
-	attrs := appendUsage([]attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}, s.usage)
-	if s.info.Attempt > 0 {
-		attrs = append(attrs, attribute.Int(AttrAttempt, s.info.Attempt))
-	}
-	if s.info.MaxAttempts > 0 {
-		attrs = append(attrs, attribute.Int(AttrMaxAttempts, s.info.MaxAttempts))
-	}
-	if err != nil {
-		attrs = append(attrs, attribute.String(AttrErrorKind, e.ErrorKind))
-		s.span.RecordError(err)
-		s.span.SetStatus(codes.Error, err.Error())
-	} else {
-		s.span.SetStatus(codes.Ok, "")
-	}
-	s.span.SetAttributes(attrs...)
-	s.a.recordSpanEvent(s.span, e)
-	s.span.End()
-}
-
-func mergeUsage(current, next ai.Usage) ai.Usage {
-	if next.InputTokens > current.InputTokens {
-		current.InputTokens = next.InputTokens
-	}
-	if next.OutputTokens > current.OutputTokens {
-		current.OutputTokens = next.OutputTokens
-	}
-	if next.TotalTokens > current.TotalTokens {
-		current.TotalTokens = next.TotalTokens
-	}
-	return current
-}
-
 func appendUsage(attrs []attribute.KeyValue, u ai.Usage) []attribute.KeyValue {
 	if u.InputTokens > 0 {
 		attrs = append(attrs, attribute.Int(AttrInputTokens, u.InputTokens))
@@ -365,42 +204,25 @@ func (a *agentImpl) traceTool(next ai.ToolHandler) ai.ToolHandler {
 		if a.opts.TraceProvider == nil {
 			res := next(ctx, call)
 			dur := time.Since(start).Milliseconds()
-			resErr := resultError(res)
-			toolAttempts := res.Attempts
-			if toolAttempts <= 0 {
-				toolAttempts = 1
-			}
-			a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, Attempt: toolAttempts, MaxAttempts: a.opts.ToolMaxAttempts, LatencyMS: dur, Refused: res.Refused, Error: resErr, ErrorKind: classifyToolError(resErr)})
+			a.recordRunEvent(RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, LatencyMS: dur, Refused: res.Refused, Error: resultError(res)})
 			return res
 		}
 
-		spanAttrs := appendRunInfoAttributes([]attribute.KeyValue{
+		ctx, span := a.tracer().Start(ctx, spanNameToolCall, trace.WithAttributes(
 			attribute.String(AttrRunID, info.RunID),
 			attribute.String(AttrParentRunID, info.ParentID),
 			attribute.String(AttrAgentName, info.Agent),
 			attribute.String(AttrToolName, call.Name),
 			attribute.Bool(AttrDelegate, call.Name == toolDelegate),
-		}, info)
-		ctx, span := a.tracer().Start(ctx, spanNameToolCall, trace.WithAttributes(spanAttrs...))
+		))
 		res := next(ctx, call)
 		dur := time.Since(start).Milliseconds()
 		attrs := []attribute.KeyValue{attribute.Int64(AttrLatencyMS, dur)}
-		toolAttempts := res.Attempts
-		if toolAttempts <= 0 {
-			toolAttempts = 1
-		}
-		attrs = append(attrs, attribute.Int(AttrToolAttempt, toolAttempts))
-		if a.opts.ToolMaxAttempts > 0 {
-			attrs = append(attrs, attribute.Int(AttrToolMaxAttempts, a.opts.ToolMaxAttempts))
-		}
 		if res.Refused != "" {
 			attrs = append(attrs, attribute.Bool(AttrGuardrailBlock, true), attribute.String(AttrRefusal, res.Refused))
 		}
-		resErr := resultError(res)
-		if kind := classifyToolError(resErr); kind != "" {
-			attrs = append(attrs, attribute.String(AttrErrorKind, kind))
-		}
 		span.SetAttributes(attrs...)
+		resErr := resultError(res)
 		if res.Refused != "" {
 			span.SetStatus(codes.Error, res.Refused)
 		} else if resErr != "" {
@@ -408,8 +230,8 @@ func (a *agentImpl) traceTool(next ai.ToolHandler) ai.ToolHandler {
 		} else {
 			span.SetStatus(codes.Ok, "")
 		}
-		a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, Attempt: toolAttempts, MaxAttempts: a.opts.ToolMaxAttempts, LatencyMS: dur, Refused: res.Refused, Error: resErr, ErrorKind: classifyToolError(resErr)})
 		span.End()
+		a.recordSpanEvent(span, RunEvent{Time: time.Now(), RunID: info.RunID, ParentID: info.ParentID, Agent: info.Agent, Kind: "tool", Name: call.Name, LatencyMS: dur, Refused: res.Refused, Error: resErr})
 		return res
 	}
 }
@@ -426,28 +248,6 @@ func resultError(res ai.ToolResult) string {
 	return ""
 }
 
-func classifyToolError(err string) string {
-	switch {
-	case err == "":
-		return ""
-	case strings.Contains(strings.ToLower(err), "context canceled"):
-		return string(ai.ErrorKindCanceled)
-	case strings.Contains(strings.ToLower(err), "deadline exceeded"):
-		return string(ai.ErrorKindTimeout)
-	default:
-		return string(ai.ErrorKindProvider)
-	}
-}
-
-func (a *agentImpl) recordTimelineEvent(ctx context.Context, e RunEvent) {
-	span := trace.SpanFromContext(ctx)
-	if span.SpanContext().IsValid() {
-		a.recordSpanEvent(span, e)
-		return
-	}
-	a.recordRunEvent(e)
-}
-
 func (a *agentImpl) recordSpanEvent(span trace.Span, e RunEvent) {
 	if sc := span.SpanContext(); sc.IsValid() {
 		e.TraceID = sc.TraceID().String()
@@ -461,7 +261,6 @@ func runEventAttributes(e RunEvent) []attribute.KeyValue {
 	attrs := []attribute.KeyValue{
 		attribute.String(AttrRunID, e.RunID),
 		attribute.String(AttrAgentName, e.Agent),
-		attribute.String(AttrRunEventKind, e.Kind),
 	}
 	if e.ParentID != "" {
 		attrs = append(attrs, attribute.String(AttrParentRunID, e.ParentID))
@@ -475,26 +274,9 @@ func runEventAttributes(e RunEvent) []attribute.KeyValue {
 	if e.Model != "" {
 		attrs = append(attrs, attribute.String(AttrModel, e.Model))
 	}
-	if e.Attempt > 0 {
-		if e.Kind == "tool" {
-			attrs = append(attrs, attribute.Int(AttrToolAttempt, e.Attempt))
-		} else {
-			attrs = append(attrs, attribute.Int(AttrAttempt, e.Attempt))
-		}
-	}
-	if e.MaxAttempts > 0 {
-		if e.Kind == "tool" {
-			attrs = append(attrs, attribute.Int(AttrToolMaxAttempts, e.MaxAttempts))
-		} else {
-			attrs = append(attrs, attribute.Int(AttrMaxAttempts, e.MaxAttempts))
-		}
-	}
 	if e.LatencyMS > 0 {
 		attrs = append(attrs, attribute.Int64(AttrLatencyMS, e.LatencyMS))
 	}
-	if e.InputChars > 0 {
-		attrs = append(attrs, attribute.Int(AttrInputChars, e.InputChars))
-	}
 	attrs = appendUsage(attrs, e.Tokens)
 	if e.Refused != "" {
 		attrs = append(attrs, attribute.Bool(AttrGuardrailBlock, true), attribute.String(AttrRefusal, e.Refused))
@@ -502,33 +284,6 @@ func runEventAttributes(e RunEvent) []attribute.KeyValue {
 	if e.Error != "" {
 		attrs = append(attrs, attribute.String("agent.error", e.Error))
 	}
-	if e.ErrorKind != "" {
-		attrs = append(attrs, attribute.String(AttrErrorKind, e.ErrorKind))
-	}
-	if e.Kind == "checkpoint" {
-		if e.Status != "" {
-			attrs = append(attrs, attribute.String(AttrCheckpointStatus, e.Status))
-		}
-		if e.Name != "" {
-			attrs = append(attrs, attribute.String(AttrCheckpointStage, e.Name))
-		}
-	}
-	return attrs
-}
-
-func appendRunInfoAttributes(attrs []attribute.KeyValue, info ai.RunInfo) []attribute.KeyValue {
-	if info.Flow != "" {
-		attrs = append(attrs, attribute.String(AttrFlowName, info.Flow))
-	}
-	if info.Step != "" {
-		attrs = append(attrs, attribute.String(AttrFlowStep, info.Step))
-	}
-	if info.Dispatch != "" {
-		attrs = append(attrs, attribute.String(AttrDispatch, info.Dispatch))
-	}
-	if info.Trigger != "" {
-		attrs = append(attrs, attribute.String(AttrTrigger, info.Trigger))
-	}
 	return attrs
 }
 
@@ -605,16 +360,9 @@ func ListRunSummariesWithOptions(s store.Store, agentName string, opts RunListOp
 			if e.SpanID != "" {
 				summary.SpanID = e.SpanID
 			}
-			if e.Kind == "checkpoint" {
-				summary.Checkpoint = e.Status
-				summary.Stage = e.Name
-			}
 			if e.Error != "" {
 				summary.LastError = e.Error
 			}
-			if e.ErrorKind != "" {
-				summary.LastErrorKind = e.ErrorKind
-			}
 		}
 		if opts.Status != "" && summary.Status != opts.Status {
 			continue
@@ -641,32 +389,24 @@ func runStatus(events []RunEvent) string {
 	}
 	status := "running"
 	for _, e := range events {
-		if e.Refused != "" && status == "running" {
+		if e.Error != "" {
+			status = "error"
+		}
+		if e.Refused != "" && status != "error" {
 			status = "refused"
 		}
-		if e.Error != "" || e.Kind == "error" {
-			status = runErrorStatus(e.ErrorKind)
-		}
-		if e.Kind == "done" {
-			status = "done"
+		switch e.Kind {
+		case "error":
+			status = "error"
+		case "done":
+			if status == "running" {
+				status = "done"
+			}
 		}
 	}
 	return status
 }
 
-func runErrorStatus(kind string) string {
-	switch ai.ErrorKind(kind) {
-	case ai.ErrorKindCanceled:
-		return "canceled"
-	case ai.ErrorKindTimeout:
-		return "timeout"
-	case ai.ErrorKindRateLimited:
-		return "rate_limited"
-	default:
-		return "error"
-	}
-}
-
 func LoadRunEvents(s store.Store, agentName, runID string) ([]RunEvent, error) {
 	st := store.Scope(s, "agent", agentName)
 	keys, err := st.List(store.ListPrefix("runs/" + runID + "/"))

agent/otel_test.go

@@ -3,24 +3,18 @@ package agent
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
-	"io"
 	"strings"
 	"testing"
 	"time"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
 	"go-micro.dev/v6/store"
 	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/sdk/trace"
 	"go.opentelemetry.io/otel/sdk/trace/tracetest"
 )
 
-const codesError = codes.Error
-
 type otelTestModel struct{ opts ai.Options }
 
 func (m *otelTestModel) Init(opts ...ai.Option) error {
@@ -95,19 +89,6 @@ func TestAgentOpenTelemetrySpans(t *testing.T) {
 		if attrs[AttrRunID] != runID || attrs[AttrAgentName] != "runner" {
 			t.Fatalf("%s missing run correlation attributes: %#v", s.Name(), attrs)
 		}
-		if s.Name() == spanNameModelCall {
-			if attrs[AttrAttempt] != "1" || attrs[AttrMaxAttempts] != "1" {
-				t.Fatalf("model span missing attempt attributes: %#v", attrs)
-			}
-			if !spanEventHasRunInfo(s.Events(), "agent.model", runID, "runner") {
-				t.Fatalf("model span missing model event: %#v", s.Events())
-			}
-		}
-		if s.Name() == spanNameToolCall {
-			if !spanEventHasRunInfo(s.Events(), "agent.tool", runID, "runner") {
-				t.Fatalf("tool span missing tool event: %#v", s.Events())
-			}
-		}
 	}
 	keys, err := store.Scope(st, "agent", "runner").List(store.ListPrefix("runs/"))
 	if err != nil {
@@ -144,269 +125,13 @@ func TestAgentOpenTelemetrySpans(t *testing.T) {
 	}
 }
 
-func TestAgentOpenTelemetryToolSpanIncludesWorkflowRunInfo(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	a := New(Name("workflow-tool"), Provider("oteltest"), WithStore(st), TraceProvider(tp)).(*agentImpl)
-	handler := a.traceTool(func(context.Context, ai.ToolCall) ai.ToolResult {
-		return ai.ToolResult{Value: "ok"}
-	})
-	ctx := ai.WithRunInfo(context.Background(), ai.RunInfo{
-		RunID:    "run-workflow-tool",
-		ParentID: "parent-run",
-		Agent:    "workflow-tool",
-		Flow:     "deploy",
-		Step:     "notify",
-		Dispatch: "workflow",
-		Trigger:  "manual",
-	})
-
-	res := handler(ctx, ai.ToolCall{ID: "call-1", Name: "notify", Input: map[string]any{"ok": true}})
-	if resultError(res) != "" {
-		t.Fatalf("tool returned error: %#v", res)
-	}
-
-	for _, span := range exp.GetSpans().Snapshots() {
-		if span.Name() != spanNameToolCall {
-			continue
-		}
-		attrs := spanAttributes(span.Attributes())
-		if attrs[AttrRunID] != "run-workflow-tool" || attrs[AttrParentRunID] != "parent-run" || attrs[AttrAgentName] != "workflow-tool" {
-			t.Fatalf("tool span missing run lineage: %#v", attrs)
-		}
-		if attrs[AttrFlowName] != "deploy" || attrs[AttrFlowStep] != "notify" || attrs[AttrDispatch] != "workflow" || attrs[AttrTrigger] != "manual" {
-			t.Fatalf("tool span missing workflow run info: %#v", attrs)
-		}
-		return
-	}
-	t.Fatalf("tool span not emitted; got %d spans", len(exp.GetSpans().Snapshots()))
-}
-
-func TestAgentOpenTelemetryToolRetryAttempts(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	calls := 0
-	a := New(
-		Name("tool-retry-otel"),
-		Provider("oteltest"),
-		WithStore(st),
-		TraceProvider(tp),
-		ToolRetry(3, time.Millisecond),
-		WithTool("probe", "probe", nil, func(context.Context, map[string]any) (string, error) {
-			calls++
-			if calls == 1 {
-				return "", errors.New("rate limit exceeded")
-			}
-			return "ok", nil
-		}),
-	)
-	if _, err := a.Ask(context.Background(), "hello"); err != nil {
-		t.Fatal(err)
-	}
-	if calls != 2 {
-		t.Fatalf("tool calls = %d, want retry success after 2 attempts", calls)
-	}
-
-	var sawToolSpan bool
-	for _, span := range exp.GetSpans().Snapshots() {
-		if span.Name() != spanNameToolCall {
-			continue
-		}
-		attrs := spanAttributes(span.Attributes())
-		if attrs[AttrToolName] != "probe" {
-			continue
-		}
-		if attrs[AttrToolAttempt] != "2" || attrs[AttrToolMaxAttempts] != "3" {
-			t.Fatalf("tool retry span attempts = %#v", attrs)
-		}
-		if !spanEventHasAttr(span.Events(), "agent.tool", AttrToolAttempt, "2") || !spanEventHasAttr(span.Events(), "agent.tool", AttrToolMaxAttempts, "3") {
-			t.Fatalf("tool retry event missing attempt attributes: %#v", span.Events())
-		}
-		sawToolSpan = true
-	}
-	if !sawToolSpan {
-		t.Fatal("tool retry span not emitted")
-	}
-
-	summaries, err := ListRunSummaries(st, "tool-retry-otel")
-	if err != nil {
-		t.Fatal(err)
-	}
-	events, err := LoadRunEvents(st, "tool-retry-otel", summaries[0].RunID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, event := range events {
-		if event.Kind == "tool" && event.Name == "probe" && event.Attempt == 2 && event.MaxAttempts == 3 {
-			return
-		}
-	}
-	t.Fatalf("persisted tool event missing retry attempts: %#v", events)
-}
-
-func spanEventHasAttr(events []trace.Event, name, key, value string) bool {
-	for _, event := range events {
-		if event.Name != name {
-			continue
-		}
-		attrs := spanAttributes(event.Attributes)
-		if attrs[key] == value {
-			return true
-		}
-	}
-	return false
-}
-
-func TestAgentRunObservabilityRedactsInputByDefault(t *testing.T) {
-	secret := "deploy production with token sk-secret"
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	a := New(Name("redactor"), Provider("oteltest"), WithStore(st), TraceProvider(tp))
-	if _, err := a.Ask(context.Background(), secret); err != nil {
-		t.Fatal(err)
-	}
-
-	spans := exp.GetSpans().Snapshots()
-	var sawInputChars bool
-	for _, s := range spans {
-		for _, event := range s.Events() {
-			attrs := spanAttributes(event.Attributes)
-			if attrs["agent.event.name"] == secret {
-				t.Fatalf("span event leaked raw input: %#v", event)
-			}
-			if attrs[AttrInputChars] == fmt.Sprint(len(secret)) {
-				sawInputChars = true
-			}
-		}
-	}
-	if !sawInputChars {
-		t.Fatal("run event missing redacted input length attribute")
-	}
-
-	summaries, err := ListRunSummaries(st, "redactor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	events, err := LoadRunEvents(st, "redactor", summaries[0].RunID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, event := range events {
-		if event.Name == secret {
-			t.Fatalf("persisted run event leaked raw input: %#v", event)
-		}
-		if event.Kind == "run" && event.InputChars != len(secret) {
-			t.Fatalf("run event InputChars = %d, want %d", event.InputChars, len(secret))
-		}
-	}
-}
-
-func TestAgentTraceInputsOptInRecordsInput(t *testing.T) {
-	message := "operator-approved diagnostic prompt"
-	st := store.NewMemoryStore()
-	a := New(Name("input-opt-in"), Provider("oteltest"), WithStore(st), TraceInputs(true))
-	if _, err := a.Ask(context.Background(), message); err != nil {
-		t.Fatal(err)
-	}
-
-	summaries, err := ListRunSummaries(st, "input-opt-in")
-	if err != nil {
-		t.Fatal(err)
-	}
-	events, err := LoadRunEvents(st, "input-opt-in", summaries[0].RunID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, event := range events {
-		if event.Kind == "run" && event.Name == message {
-			return
-		}
-	}
-	t.Fatalf("opt-in run event did not record message: %#v", events)
-}
-
-type failingOtelModel struct{ opts ai.Options }
-
-func (m *failingOtelModel) Init(opts ...ai.Option) error {
-	for _, o := range opts {
-		o(&m.opts)
-	}
-	return nil
-}
-func (m *failingOtelModel) Options() ai.Options { return m.opts }
-func (m *failingOtelModel) String() string      { return "otelfail" }
-func (m *failingOtelModel) Stream(context.Context, *ai.Request, ...ai.GenerateOption) (ai.Stream, error) {
-	return nil, nil
-}
-func (m *failingOtelModel) Generate(context.Context, *ai.Request, ...ai.GenerateOption) (*ai.Response, error) {
-	return nil, errors.New("provider exploded")
-}
-
-func init() {
-	ai.Register("otelfail", func(opts ...ai.Option) ai.Model { return &failingOtelModel{opts: ai.NewOptions(opts...)} })
-}
-
-func TestAgentOpenTelemetrySpansModelFailure(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	a := New(Name("failing-runner"), Provider("otelfail"), WithStore(st), TraceProvider(tp))
-	if _, err := a.Ask(context.Background(), "hello"); err == nil {
-		t.Fatal("Ask succeeded, want provider error")
-	}
-
-	spans := exp.GetSpans().Snapshots()
-	var sawRunError, sawModelError bool
-	for _, s := range spans {
-		attrs := spanAttributes(s.Attributes())
-		switch s.Name() {
-		case spanNameRun:
-			if attrs[AttrAgentName] == "failing-runner" && s.Status().Code == codesError {
-				sawRunError = true
-			}
-		case spanNameModelCall:
-			if attrs[AttrAgentName] == "failing-runner" && attrs[AttrAttempt] == "1" && attrs[AttrErrorKind] == string(ai.ErrorKindUnknown) && s.Status().Code == codesError {
-				sawModelError = true
-			}
-		}
-	}
-	if !sawRunError || !sawModelError {
-		t.Fatalf("missing error spans: run=%v model=%v spans=%d", sawRunError, sawModelError, len(spans))
-	}
-
-	summaries, err := ListRunSummaries(st, "failing-runner")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(summaries) != 1 || summaries[0].Status != "error" || summaries[0].LastError == "" {
-		t.Fatalf("unexpected failure summary: %#v", summaries)
-	}
-	events, err := LoadRunEvents(st, "failing-runner", summaries[0].RunID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var sawModelEvent bool
-	for _, event := range events {
-		if event.Kind == "model" && event.Attempt == 1 && event.MaxAttempts == 1 && event.Error != "" && event.ErrorKind == string(ai.ErrorKindUnknown) {
-			sawModelEvent = true
-		}
-	}
-	if !sawModelEvent {
-		t.Fatalf("missing failed model event with attempt metadata: %#v", events)
-	}
-}
-
 func spanEventHasRunInfo(events []trace.Event, name, runID, agentName string) bool {
 	for _, event := range events {
 		if event.Name != name {
 			continue
 		}
 		attrs := spanAttributes(event.Attributes)
-		wantKind := strings.TrimPrefix(name, "agent.")
-		if attrs[AttrRunID] == runID && attrs[AttrAgentName] == agentName && attrs[AttrRunEventKind] == wantKind {
+		if attrs[AttrRunID] == runID && attrs[AttrAgentName] == agentName {
 			return true
 		}
 	}
@@ -516,74 +241,6 @@ func TestAgentRunTimelineRecordsModelAndToolWithoutTraceProvider(t *testing.T) {
 	}
 }
 
-func TestAgentCheckpointAndResumeTimelineEvents(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	cp := flow.StoreCheckpoint(st, "resume-otel-agent")
-	first := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if first {
-			first = false
-			return nil, errors.New("temporary provider failure")
-		}
-		return &ai.Response{Reply: "resumed"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("resume-otel-agent"), WithStore(st), WithCheckpoint(cp), TraceProvider(tp))
-	_, err := a.Ask(context.Background(), "resume me")
-	if err == nil {
-		t.Fatal("Ask succeeded, want simulated failure")
-	}
-
-	runs, err := cp.List(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("checkpointed runs = %d, want 1", len(runs))
-	}
-	resp, err := Resume(context.Background(), a, runs[0].ID)
-	if err != nil {
-		t.Fatalf("Resume: %v", err)
-	}
-	if resp.Reply != "resumed" {
-		t.Fatalf("reply = %q, want resumed", resp.Reply)
-	}
-
-	events, err := LoadRunEvents(st, "resume-otel-agent", runs[0].ID)
-	if err != nil {
-		t.Fatal(err)
-	}
-	seen := map[string]bool{"checkpoint": false, "resume": false}
-	for _, e := range events {
-		if _, ok := seen[e.Kind]; ok {
-			seen[e.Kind] = true
-		}
-	}
-	for kind, ok := range seen {
-		if !ok {
-			t.Fatalf("missing %s event in timeline: %#v", kind, events)
-		}
-	}
-
-	var resumeSpanEvent bool
-	for _, s := range exp.GetSpans().Snapshots() {
-		if s.Name() != spanNameRun {
-			continue
-		}
-		for _, e := range s.Events() {
-			if e.Name == "agent.resume" {
-				resumeSpanEvent = true
-			}
-		}
-	}
-	if !resumeSpanEvent {
-		t.Fatal("run span missing agent.resume event")
-	}
-}
-
 func TestLoadRunEventsSortsTimelineKeys(t *testing.T) {
 	st := store.NewMemoryStore()
 	scoped := store.Scope(st, "agent", "runner")
@@ -625,8 +282,7 @@ func TestListRunSummaries(t *testing.T) {
 		{Time: time.Unix(0, 1), RunID: "run-a", Agent: "runner", TraceID: "trace-a", SpanID: "span-a", Kind: "run", Name: "first"},
 		{Time: time.Unix(0, 2), RunID: "run-a", Agent: "runner", Kind: "tool", Name: "probe"},
 		{Time: time.Unix(0, 3), RunID: "run-b", Agent: "runner", ParentID: "parent", Kind: "run", Name: "second"},
-		{Time: time.Unix(0, 4), RunID: "run-b", Agent: "runner", ParentID: "parent", Kind: "checkpoint", Name: "ask", Status: "failed"},
-		{Time: time.Unix(0, 5), RunID: "run-b", Agent: "runner", ParentID: "parent", Kind: "error", Error: "context deadline exceeded", ErrorKind: string(ai.ErrorKindTimeout)},
+		{Time: time.Unix(0, 4), RunID: "run-b", Agent: "runner", ParentID: "parent", Kind: "error", Error: "boom"},
 	}
 	for _, e := range events {
 		b, err := json.Marshal(e)
@@ -649,35 +305,11 @@ func TestListRunSummaries(t *testing.T) {
 	if got[0].RunID != "run-a" || got[0].TraceID != "trace-a" || got[0].SpanID != "span-a" || got[0].Events != 2 || got[0].Status != "running" || got[0].DurationMS != 0 || got[0].LastKind != "tool" || !got[0].UpdatedAt.Equal(time.Unix(0, 2)) {
 		t.Fatalf("unexpected run-a summary: %#v", got[0])
 	}
-	if got[1].RunID != "run-b" || got[1].ParentID != "parent" || got[1].Events != 3 || got[1].Status != "timeout" || got[1].DurationMS != 0 || got[1].LastKind != "error" || got[1].Checkpoint != "failed" || got[1].Stage != "ask" || got[1].LastError != "context deadline exceeded" || got[1].LastErrorKind != string(ai.ErrorKindTimeout) {
+	if got[1].RunID != "run-b" || got[1].ParentID != "parent" || got[1].Events != 2 || got[1].Status != "error" || got[1].DurationMS != 0 || got[1].LastKind != "error" || got[1].LastError != "boom" {
 		t.Fatalf("unexpected run-b summary: %#v", got[1])
 	}
 }
 
-func TestRunStatusClassifiesOperationalErrorKinds(t *testing.T) {
-	tests := []struct {
-		name string
-		kind ai.ErrorKind
-		want string
-	}{
-		{name: "canceled", kind: ai.ErrorKindCanceled, want: "canceled"},
-		{name: "timeout", kind: ai.ErrorKindTimeout, want: "timeout"},
-		{name: "rate limited", kind: ai.ErrorKindRateLimited, want: "rate_limited"},
-		{name: "provider", kind: ai.ErrorKindProvider, want: "error"},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := runStatus([]RunEvent{
-				{Kind: "run"},
-				{Kind: "error", Error: "failed", ErrorKind: string(tt.kind)},
-			})
-			if got != tt.want {
-				t.Fatalf("runStatus() = %q, want %q", got, tt.want)
-			}
-		})
-	}
-}
-
 func TestListRunSummariesWithOptionsFiltersAndLimits(t *testing.T) {
 	st := store.NewMemoryStore()
 	scoped := store.Scope(st, "agent", "runner")
@@ -685,7 +317,7 @@ func TestListRunSummariesWithOptionsFiltersAndLimits(t *testing.T) {
 		{Time: time.Unix(0, 1), RunID: "run-old", Agent: "runner", Kind: "run"},
 		{Time: time.Unix(0, 2), RunID: "run-old", Agent: "runner", Kind: "done"},
 		{Time: time.Unix(0, 3), RunID: "run-new", Agent: "runner", TraceID: "abcdef1234567890", Kind: "run"},
-		{Time: time.Unix(0, 4), RunID: "run-new", Agent: "runner", Kind: "error", Error: "rate limit exceeded", ErrorKind: string(ai.ErrorKindRateLimited)},
+		{Time: time.Unix(0, 4), RunID: "run-new", Agent: "runner", Kind: "error", Error: "boom"},
 	}
 	for _, e := range events {
 		b, err := json.Marshal(e)
@@ -697,103 +329,11 @@ func TestListRunSummariesWithOptionsFiltersAndLimits(t *testing.T) {
 		}
 	}
 
-	got, err := ListRunSummariesWithOptions(st, "runner", RunListOptions{Status: "rate_limited", TraceID: "abcdef", Limit: 1})
+	got, err := ListRunSummariesWithOptions(st, "runner", RunListOptions{Status: "error", TraceID: "abcdef", Limit: 1})
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(got) != 1 || got[0].RunID != "run-new" || got[0].Status != "rate_limited" {
+	if len(got) != 1 || got[0].RunID != "run-new" || got[0].Status != "error" {
 		t.Fatalf("filtered summaries = %#v", got)
 	}
 }
-
-type otelStreamModel struct{ opts ai.Options }
-
-func (m *otelStreamModel) Init(opts ...ai.Option) error {
-	for _, o := range opts {
-		o(&m.opts)
-	}
-	return nil
-}
-func (m *otelStreamModel) Options() ai.Options { return m.opts }
-func (m *otelStreamModel) String() string      { return "otelstream" }
-func (m *otelStreamModel) Generate(context.Context, *ai.Request, ...ai.GenerateOption) (*ai.Response, error) {
-	return &ai.Response{Reply: "unused"}, nil
-}
-func (m *otelStreamModel) Stream(context.Context, *ai.Request, ...ai.GenerateOption) (ai.Stream, error) {
-	return &otelTestStream{chunks: []*ai.Response{{Reply: "one", Usage: ai.Usage{InputTokens: 1, OutputTokens: 2, TotalTokens: 3}}, {Reply: "two", Usage: ai.Usage{InputTokens: 1, OutputTokens: 4, TotalTokens: 5}}}}, nil
-}
-
-type otelTestStream struct {
-	chunks []*ai.Response
-	idx    int
-}
-
-func (s *otelTestStream) Recv() (*ai.Response, error) {
-	if s.idx >= len(s.chunks) {
-		return nil, io.EOF
-	}
-	resp := s.chunks[s.idx]
-	s.idx++
-	return resp, nil
-}
-
-func (s *otelTestStream) Close() error { return nil }
-
-func TestAgentOpenTelemetrySpansModelStream(t *testing.T) {
-	exp := tracetest.NewInMemoryExporter()
-	tp := trace.NewTracerProvider(trace.WithSyncer(exp))
-	st := store.NewMemoryStore()
-	a := New(Name("stream-runner"), Provider("oteltest"), Model("stream-model"), WithStore(st), TraceProvider(tp))
-	m := a.(*agentImpl).tracedModel(&otelStreamModel{opts: ai.Options{Model: "stream-model"}})
-	ctx := ai.WithRunInfo(context.Background(), ai.RunInfo{RunID: "stream-run-1", ParentID: "parent-run", Agent: "stream-runner", Attempt: 2, MaxAttempts: 3, Flow: "deploy", Step: "plan"})
-
-	stream, err := m.Stream(ctx, &ai.Request{Prompt: "stream"})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for {
-		_, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := stream.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	spans := exp.GetSpans().Snapshots()
-	var sawStream bool
-	for _, s := range spans {
-		if s.Name() != spanNameModelStream {
-			continue
-		}
-		attrs := spanAttributes(s.Attributes())
-		if attrs[AttrRunID] != "stream-run-1" || attrs[AttrParentRunID] != "parent-run" || attrs[AttrAgentName] != "stream-runner" {
-			t.Fatalf("stream span missing run lineage: %#v", attrs)
-		}
-		if attrs[AttrFlowName] != "deploy" || attrs[AttrFlowStep] != "plan" {
-			t.Fatalf("stream span missing workflow attributes: %#v", attrs)
-		}
-		if attrs[AttrAttempt] != "2" || attrs[AttrMaxAttempts] != "3" || attrs[AttrTotalTokens] != "5" {
-			t.Fatalf("stream span missing attempt/usage attributes: %#v", attrs)
-		}
-		if !spanEventHasRunInfo(s.Events(), "agent.stream", "stream-run-1", "stream-runner") {
-			t.Fatalf("stream span missing stream event: %#v", s.Events())
-		}
-		sawStream = true
-	}
-	if !sawStream {
-		t.Fatalf("stream span not emitted; got %d spans", len(spans))
-	}
-
-	events, err := LoadRunEvents(st, "stream-runner", "stream-run-1")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(events) != 1 || events[0].Kind != "stream" || events[0].TraceID == "" || events[0].SpanID == "" || events[0].Tokens.TotalTokens != 5 {
-		t.Fatalf("unexpected stream run event: %#v", events)
-	}
-}

agent/resilience_test.go

@@ -8,8 +8,6 @@ import (
 	"time"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
-	"go-micro.dev/v6/store"
 )
 
 func TestAskCancellationAbortsPromptly(t *testing.T) {
@@ -77,86 +75,6 @@ func TestAskRetriesTransientErrorsThenSurfacesStructuredError(t *testing.T) {
 	if attempts != 2 {
 		t.Fatalf("model attempts = %d, want 2", attempts)
 	}
-	if !strings.Contains(err.Error(), "micro inspect agent <name> --status timeout") ||
-		!strings.Contains(err.Error(), "docs/guides/debugging-agents.md") {
-		t.Fatalf("Ask error = %q, want actionable timeout/debugging guidance", err.Error())
-	}
-}
-
-func TestModelRetryDoesNotDuplicateCheckpointedToolSideEffects(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewMemoryStore(), "retry-tool-dedupe-agent")
-	attempts := 0
-	toolRuns := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		attempts++
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		res := opts.ToolHandler(ctx, ai.ToolCall{ID: "create-1", Name: "external.create", Input: map[string]any{"title": "Retry safe"}})
-		if res.Content != "created Retry safe" {
-			t.Fatalf("tool result = %q, want cached create result", res.Content)
-		}
-		if attempts == 1 {
-			return nil, testStatusError{code: 503}
-		}
-		return &ai.Response{Reply: "done", ToolCalls: []ai.ToolCall{{ID: "create-1", Name: "external.create", Input: map[string]any{"title": "Retry safe"}, Result: res.Content}}}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(
-		Name("retry-tool-dedupe-agent"),
-		WithCheckpoint(cp),
-		ModelRetry(2, time.Millisecond),
-		WithTool("external.create", "create once", nil, func(context.Context, map[string]any) (string, error) {
-			toolRuns++
-			return "created Retry safe", nil
-		}),
-	)
-
-	resp, err := a.Ask(ctx, "create once despite a transient provider retry")
-	if err != nil {
-		t.Fatalf("Ask: %v", err)
-	}
-	if resp.Reply != "done" {
-		t.Fatalf("reply = %q, want done", resp.Reply)
-	}
-	if attempts != 2 {
-		t.Fatalf("model attempts = %d, want retry after transient provider failure", attempts)
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions = %d, want checkpointed side effect reused across retry", toolRuns)
-	}
-	runs, err := cp.List(ctx)
-	if err != nil {
-		t.Fatalf("List: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("checkpointed runs = %d, want 1", len(runs))
-	}
-	if _, ok := findStep(runs[0].Steps, `tool:external.create:{"title":"Retry safe"}`); !ok {
-		t.Fatalf("checkpoint steps = %#v, want completed external.create step", runs[0].Steps)
-	}
-}
-
-func TestAskRateLimitFailureSuggestsPreflightAndInspect(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		return nil, testStatusError{code: 429}
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("rate-limit-guidance"), ModelRetry(1, time.Millisecond))
-	_, err := a.Ask(context.Background(), "hello")
-	if err == nil {
-		t.Fatal("Ask succeeded, want rate-limit failure")
-	}
-	if !strings.Contains(err.Error(), "micro inspect agent <name> --status rate_limited") ||
-		!strings.Contains(err.Error(), "micro agent preflight") {
-		t.Fatalf("Ask error = %q, want inspect and preflight guidance", err.Error())
-	}
-	if ai.ClassifyError(err) != ai.ErrorKindRateLimited {
-		t.Fatalf("ClassifyError(wrapped error) = %q, want rate_limited", ai.ClassifyError(err))
-	}
 }
 
 func TestCanceledAskContextSkipsToolExecution(t *testing.T) {
@@ -184,205 +102,3 @@ func TestCanceledAskContextSkipsToolExecution(t *testing.T) {
 		t.Fatalf("plan persisted after canceled tool context: %q", plan)
 	}
 }
-
-func TestToolCallTimeoutPropagatesDeadlineToCustomTool(t *testing.T) {
-	var sawDeadline bool
-	a := newTestAgent(
-		Name("tool-timeout"),
-		ToolCallTimeout(10*time.Millisecond),
-		WithTool("slow", "slow tool", nil, func(ctx context.Context, input map[string]any) (string, error) {
-			if _, ok := ctx.Deadline(); ok {
-				sawDeadline = true
-			}
-			<-ctx.Done()
-			return "", ctx.Err()
-		}),
-	)
-
-	start := time.Now()
-	content := toolContent(a.toolHandler(), "slow", nil)
-	if !sawDeadline {
-		t.Fatal("custom tool did not receive a deadline")
-	}
-	if !strings.Contains(content, context.DeadlineExceeded.Error()) {
-		t.Fatalf("tool result = %q, want deadline exceeded", content)
-	}
-	if elapsed := time.Since(start); elapsed > 200*time.Millisecond {
-		t.Fatalf("tool call took %s, want bounded timeout", elapsed)
-	}
-}
-
-func TestAskCancellationDuringToolCallFailsRun(t *testing.T) {
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "cancel-self"})
-		if !strings.Contains(res.Content, context.Canceled.Error()) {
-			t.Fatalf("tool result = %q, want cancellation error", res.Content)
-		}
-		return &ai.Response{Reply: "should not succeed"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	ctx, cancel := context.WithCancel(context.Background())
-	a := newTestAgent(
-		Name("cancel-during-tool"),
-		WithTool("cancel-self", "cancel the run context", nil, func(context.Context, map[string]any) (string, error) {
-			cancel()
-			return "", context.Canceled
-		}),
-	)
-
-	_, err := a.Ask(ctx, "cancel during tool")
-	if !errors.Is(err, context.Canceled) {
-		t.Fatalf("Ask error = %v, want context canceled", err)
-	}
-}
-
-func TestSlowProviderTimeoutPreventsLateToolSideEffects(t *testing.T) {
-	started := make(chan struct{})
-	release := make(chan struct{})
-	done := make(chan struct{})
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		close(started)
-		<-release
-		defer close(done)
-		if opts.ToolHandler == nil {
-			t.Fatal("missing tool handler")
-		}
-		res := opts.ToolHandler(ctx, ai.ToolCall{ID: "late-1", Name: "external.create", Input: map[string]any{"title": "too late"}})
-		if !strings.Contains(res.Content, context.DeadlineExceeded.Error()) {
-			t.Errorf("late tool result = %q, want deadline exceeded", res.Content)
-		}
-		return &ai.Response{Reply: "late", ToolCalls: []ai.ToolCall{{ID: "late-1", Name: "external.create", Input: map[string]any{"title": "too late"}, Result: res.Content}}}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	toolRuns := 0
-	a := newTestAgent(
-		Name("slow-provider-late-tool"),
-		ModelCallTimeout(10*time.Millisecond),
-		WithTool("external.create", "create once", nil, func(context.Context, map[string]any) (string, error) {
-			toolRuns++
-			return "created", nil
-		}),
-	)
-
-	_, err := a.Ask(context.Background(), "provider times out before tool")
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Fatalf("Ask error = %v, want deadline exceeded", err)
-	}
-	select {
-	case <-started:
-	default:
-		t.Fatal("provider was not called")
-	}
-	close(release)
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatal("late provider call did not finish")
-	}
-	if toolRuns != 0 {
-		t.Fatalf("late tool executions = %d, want 0", toolRuns)
-	}
-}
-
-func TestAskCheckpointRecordsTerminalOperationalFailureStatus(t *testing.T) {
-	tests := []struct {
-		name string
-		err  error
-		want string
-	}{
-		{name: "canceled", err: context.Canceled, want: "canceled"},
-		{name: "timeout", err: context.DeadlineExceeded, want: "timeout"},
-		{name: "rate limited", err: testStatusError{code: 429}, want: "rate_limited"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			cp := flow.StoreCheckpoint(store.NewMemoryStore(), "terminal-"+strings.ReplaceAll(tt.name, " ", "-"))
-			fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-				return nil, tt.err
-			}
-			defer func() { fakeGen = nil }()
-
-			a := newTestAgent(Name("terminal-"+strings.ReplaceAll(tt.name, " ", "-")), WithCheckpoint(cp))
-			_, err := a.Ask(context.Background(), "fail safely")
-			if err == nil {
-				t.Fatal("Ask succeeded, want failure")
-			}
-
-			runs, err := cp.List(context.Background())
-			if err != nil {
-				t.Fatalf("List: %v", err)
-			}
-			if len(runs) != 1 {
-				t.Fatalf("checkpointed runs = %d, want 1", len(runs))
-			}
-			if runs[0].Status != tt.want {
-				t.Fatalf("run status = %q, want %q", runs[0].Status, tt.want)
-			}
-			if len(runs[0].Steps) == 0 || runs[0].Steps[0].Status != tt.want {
-				t.Fatalf("step status = %#v, want %q", runs[0].Steps, tt.want)
-			}
-			if pending, err := Pending(context.Background(), a); err != nil || len(pending) != 0 {
-				t.Fatalf("Pending = %#v, %v; want no terminal run", pending, err)
-			}
-		})
-	}
-}
-
-type testStatusError struct {
-	code int
-}
-
-func (e testStatusError) Error() string { return "provider status error" }
-
-func (e testStatusError) StatusCode() int { return e.code }
-
-func TestToolRetryRetriesTransientToolErrorsThenSucceeds(t *testing.T) {
-	attempts := 0
-	a := newTestAgent(
-		Name("tool-retry-success"),
-		ToolRetry(3, time.Millisecond),
-		WithTool("flaky", "flaky tool", nil, func(context.Context, map[string]any) (string, error) {
-			attempts++
-			if attempts < 3 {
-				return "", context.DeadlineExceeded
-			}
-			return "ok", nil
-		}),
-	)
-
-	content := toolContent(a.toolHandler(), "flaky", nil)
-	if content != "ok" {
-		t.Fatalf("tool result = %q, want ok", content)
-	}
-	if attempts != 3 {
-		t.Fatalf("attempts = %d, want 3", attempts)
-	}
-}
-
-func TestToolRetryDoesNotRetryGuardrailRefusals(t *testing.T) {
-	attempts := 0
-	a := newTestAgent(
-		Name("tool-retry-refusal"),
-		MaxSteps(1),
-		ToolRetry(3, time.Millisecond),
-		WithTool("counted", "counted tool", nil, func(context.Context, map[string]any) (string, error) {
-			attempts++
-			return "ok", nil
-		}),
-	)
-	h := a.toolHandler()
-	_ = toolContent(h, "counted", nil)
-	content := toolContent(h, "counted", nil)
-	if !strings.Contains(content, "step limit reached") {
-		t.Fatalf("tool result = %q, want step-limit refusal", content)
-	}
-	if attempts != 1 {
-		t.Fatalf("attempts = %d, want only the allowed tool call to execute", attempts)
-	}
-}

agent/stream.go

@@ -1,322 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"strings"
-	"sync"
-
-	"github.com/google/uuid"
-
-	"go-micro.dev/v6/ai"
-)
-
-// StreamEventType identifies an event emitted by a tool-aware agent stream.
-type StreamEventType string
-
-const (
-	// StreamEventToolStart is emitted immediately before a tool call runs.
-	StreamEventToolStart StreamEventType = "tool_start"
-	// StreamEventToolEnd is emitted after a tool call returns or is refused.
-	StreamEventToolEnd StreamEventType = "tool_end"
-	// StreamEventToken carries a chunk of the final answer.
-	StreamEventToken StreamEventType = "token"
-	// StreamEventDone carries the completed agent response.
-	StreamEventDone StreamEventType = "done"
-)
-
-// StreamEvent is one event from StreamAsk.
-type StreamEvent struct {
-	Type     StreamEventType
-	Token    string
-	ToolCall ai.ToolCall
-	Result   ai.ToolResult
-	Response *Response
-}
-
-// AgentStream is a stream of tool execution events followed by final-answer chunks.
-type AgentStream interface {
-	Recv() (*StreamEvent, error)
-	Close() error
-}
-
-// StreamAsk runs an agent Ask turn with tool start/end events and streams the final answer.
-// It is additive for callers that hold the public Agent interface; concrete agents also
-// expose the same method directly.
-func StreamAsk(ctx context.Context, ag Agent, message string) (AgentStream, error) {
-	streamer, ok := ag.(interface {
-		StreamAsk(context.Context, string) (AgentStream, error)
-	})
-	if !ok {
-		return nil, errors.New("agent: StreamAsk unsupported by implementation")
-	}
-	return streamer.StreamAsk(ctx, message)
-}
-
-// ResumeStreamAsk resumes a checkpointed agent run and emits the same event
-// shape as StreamAsk. Completed runs are streamed from the persisted response;
-// unfinished runs continue from their checkpoint and emit tool events for any
-// work that still needs to run. Tool calls already recorded as done in the
-// checkpoint are reused by the agent checkpoint wrapper and are not re-executed.
-func ResumeStreamAsk(ctx context.Context, ag Agent, runID string) (AgentStream, error) {
-	a, ok := ag.(*agentImpl)
-	if !ok {
-		return nil, errors.New("agent: ResumeStreamAsk unsupported by implementation")
-	}
-	return a.resumeStreamAsk(ctx, runID)
-}
-
-// StreamAsk runs tools like Ask, emits ToolStart/ToolEnd events as they execute,
-// then emits chunks of the final answer followed by a Done event.
-func (a *agentImpl) StreamAsk(ctx context.Context, message string) (AgentStream, error) {
-	streamCtx, cancel := context.WithCancel(ctx)
-	events := make(chan *StreamEvent, 16)
-	done := make(chan struct{})
-	s := &agentStream{events: events, done: done, cancel: cancel}
-
-	go func() {
-		defer close(events)
-		defer close(done)
-		resp, err := a.askWithStreamEvents(streamCtx, message, events)
-		if err != nil {
-			s.setErr(err)
-			return
-		}
-		for _, tok := range splitStreamTokens(resp.Reply) {
-			if !sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToken, Token: tok}) {
-				return
-			}
-		}
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventDone, Response: resp})
-	}()
-	return s, nil
-}
-
-func (a *agentImpl) resumeStreamAsk(ctx context.Context, runID string) (AgentStream, error) {
-	streamCtx, cancel := context.WithCancel(ctx)
-	events := make(chan *StreamEvent, 16)
-	done := make(chan struct{})
-	s := &agentStream{events: events, done: done, cancel: cancel}
-
-	go func() {
-		defer close(events)
-		defer close(done)
-		resp, err := a.resumeWithStreamEvents(streamCtx, runID, events)
-		if err != nil {
-			s.setErr(err)
-			return
-		}
-		for _, tok := range splitStreamTokens(resp.Reply) {
-			if !sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToken, Token: tok}) {
-				return
-			}
-		}
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventDone, Response: resp})
-	}()
-	return s, nil
-}
-
-func (a *agentImpl) askWithStreamEvents(ctx context.Context, message string, events chan<- *StreamEvent) (*Response, error) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	if a.tools == nil {
-		a.tools = ai.NewTools(a.opts.Registry, ai.ToolClient(a.opts.Client))
-	}
-	base := a.toolHandler()
-	handler := func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToolStart, ToolCall: call})
-		result := base(ctx, call)
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToolEnd, ToolCall: call, Result: result})
-		return result
-	}
-	a.setupWithToolHandler(handler)
-	defer a.setupWithToolHandler(nil)
-	return a.askLocked(ctx, uuid.New().String(), message, a.parentRunID, nil, true)
-}
-
-func (a *agentImpl) resumeWithStreamEvents(ctx context.Context, runID string, events chan<- *StreamEvent) (*Response, error) {
-	if a.opts.Checkpoint == nil {
-		return nil, errors.New("agent: ResumeStreamAsk requires a checkpoint")
-	}
-	run, ok, err := a.opts.Checkpoint.Load(ctx, runID)
-	if err != nil {
-		return nil, err
-	}
-	if !ok {
-		return nil, errors.New("agent: checkpointed run not found")
-	}
-	if run.Status == "done" {
-		var resp Response
-		if err := json.Unmarshal(run.State.Data, &resp); err != nil {
-			return nil, err
-		}
-		return &resp, nil
-	}
-	if terminalAgentRunStatus(run.Status) {
-		return nil, errors.New("agent: checkpointed run is terminal with status " + run.Status)
-	}
-
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if a.tools == nil {
-		a.tools = ai.NewTools(a.opts.Registry, ai.ToolClient(a.opts.Client))
-	}
-	base := a.toolHandler()
-	handler := func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToolStart, ToolCall: call})
-		result := base(ctx, call)
-		_ = sendStreamEvent(ctx, events, &StreamEvent{Type: StreamEventToolEnd, ToolCall: call, Result: result})
-		return result
-	}
-	a.setupWithToolHandler(handler)
-	defer a.setupWithToolHandler(nil)
-	if run.Status == "paused" {
-		if run.State.Stage == agentInputStep {
-			return nil, errors.New("agent: checkpointed run is input-required; resume with ResumeInput")
-		}
-		run.Status = "running"
-		run.State.Stage = agentAskStep
-	}
-	return a.askLocked(ctx, run.ID, string(run.State.Data), run.ParentID, &run, false)
-}
-
-type agentStreamAdapter struct {
-	stream AgentStream
-}
-
-type memoryRecordingStream struct {
-	stream ai.Stream
-	memory Memory
-
-	mu     sync.Mutex
-	chunks []string
-	closed bool
-}
-
-func (s *memoryRecordingStream) Recv() (*ai.Response, error) {
-	resp, err := s.stream.Recv()
-	if resp != nil && resp.Reply != "" {
-		s.mu.Lock()
-		s.chunks = append(s.chunks, resp.Reply)
-		s.mu.Unlock()
-	}
-	if errors.Is(err, io.EOF) {
-		s.recordAssistant()
-	}
-	return resp, err
-}
-
-func (s *memoryRecordingStream) Close() error {
-	s.recordAssistant()
-	return s.stream.Close()
-}
-
-func (s *memoryRecordingStream) recordAssistant() {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.closed {
-		return
-	}
-	s.closed = true
-	if reply := strings.Join(s.chunks, ""); reply != "" {
-		s.memory.Add("assistant", reply)
-	}
-}
-
-func (s *agentStreamAdapter) Recv() (*ai.Response, error) {
-	for {
-		event, err := s.stream.Recv()
-		if err != nil {
-			return nil, err
-		}
-		if event == nil {
-			continue
-		}
-		switch event.Type {
-		case StreamEventToken:
-			if event.Token == "" {
-				continue
-			}
-			return &ai.Response{Reply: event.Token}, nil
-		case StreamEventDone:
-			return nil, io.EOF
-		}
-	}
-}
-
-func (s *agentStreamAdapter) Close() error {
-	return s.stream.Close()
-}
-
-func (a *agentImpl) streamAskAI(ctx context.Context, message string) (ai.Stream, error) {
-	stream, err := a.StreamAsk(ctx, message)
-	if err != nil {
-		return nil, err
-	}
-	return &agentStreamAdapter{stream: stream}, nil
-}
-
-type agentStream struct {
-	events <-chan *StreamEvent
-	done   <-chan struct{}
-	cancel context.CancelFunc
-	mu     sync.Mutex
-	err    error
-}
-
-func (s *agentStream) Recv() (*StreamEvent, error) {
-	ev, ok := <-s.events
-	if ok {
-		return ev, nil
-	}
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	if s.err != nil {
-		return nil, s.err
-	}
-	return nil, io.EOF
-}
-
-func (s *agentStream) Close() error {
-	if s.cancel != nil {
-		s.cancel()
-	}
-	<-s.done
-	return nil
-}
-
-func (s *agentStream) setErr(err error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.err = err
-}
-
-func sendStreamEvent(ctx context.Context, events chan<- *StreamEvent, ev *StreamEvent) bool {
-	select {
-	case events <- ev:
-		return true
-	case <-ctx.Done():
-		return false
-	}
-}
-
-func splitStreamTokens(reply string) []string {
-	if reply == "" {
-		return nil
-	}
-	parts := strings.Fields(reply)
-	if len(parts) == 0 {
-		return []string{reply}
-	}
-	out := make([]string, 0, len(parts))
-	for i, part := range parts {
-		if i > 0 {
-			part = " " + part
-		}
-		out = append(out, part)
-	}
-	return out
-}

agent/stream_test.go

@@ -1,278 +0,0 @@
-package agent
-
-import (
-	"context"
-	"errors"
-	"io"
-	"testing"
-	"time"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/flow"
-	"go-micro.dev/v6/store"
-)
-
-func TestStreamAskEmitsToolEventsAndFinalTokens(t *testing.T) {
-	calls := 0
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler == nil {
-			t.Fatal("StreamAsk must configure a tool handler")
-		}
-		calls++
-		result := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "echo", Input: map[string]any{"text": "hello"}})
-		return &ai.Response{
-			Reply:     "planning",
-			Answer:    "final answer",
-			ToolCalls: []ai.ToolCall{{ID: "call-1", Name: "echo", Input: map[string]any{"text": "hello"}, Result: result.Content}},
-		}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("streamer"), WithTool("echo", "echo text", nil, func(ctx context.Context, input map[string]any) (string, error) {
-		return input["text"].(string), nil
-	}))
-	stream, err := a.StreamAsk(context.Background(), "say hello")
-	if err != nil {
-		t.Fatalf("StreamAsk: %v", err)
-	}
-
-	var types []StreamEventType
-	var tokens string
-	var done *Response
-	for {
-		event, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv: %v", err)
-		}
-		types = append(types, event.Type)
-		if event.Type == StreamEventToken {
-			tokens += event.Token
-		}
-		if event.Type == StreamEventDone {
-			done = event.Response
-		}
-	}
-
-	want := []StreamEventType{StreamEventToolStart, StreamEventToolEnd, StreamEventToken, StreamEventToken, StreamEventToken, StreamEventDone}
-	if len(types) != len(want) {
-		t.Fatalf("event types = %v, want %v", types, want)
-	}
-	for i := range want {
-		if types[i] != want[i] {
-			t.Fatalf("event types = %v, want %v", types, want)
-		}
-	}
-	if tokens != "planning final answer" {
-		t.Fatalf("tokens = %q", tokens)
-	}
-	if done == nil || done.Reply != "planning\n\nfinal answer" {
-		t.Fatalf("done response = %#v", done)
-	}
-	if calls != 1 {
-		t.Fatalf("Generate calls = %d, want 1", calls)
-	}
-}
-
-func TestStreamAskCloseCancelsInFlightModelCall(t *testing.T) {
-	started := make(chan struct{})
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		close(started)
-		<-ctx.Done()
-		return nil, ctx.Err()
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("stream-cancel"))
-	stream, err := a.StreamAsk(context.Background(), "cancel me")
-	if err != nil {
-		t.Fatalf("StreamAsk: %v", err)
-	}
-
-	select {
-	case <-started:
-	case <-time.After(time.Second):
-		t.Fatal("model call did not start")
-	}
-
-	closed := make(chan error, 1)
-	go func() { closed <- stream.Close() }()
-	select {
-	case err := <-closed:
-		if err != nil {
-			t.Fatalf("Close: %v", err)
-		}
-	case <-time.After(time.Second):
-		t.Fatal("Close did not cancel the in-flight stream")
-	}
-}
-
-func TestStreamAskHelperRejectsUnsupportedAgent(t *testing.T) {
-	_, err := StreamAsk(context.Background(), unsupportedAgent{}, "hello")
-	if err == nil {
-		t.Fatal("StreamAsk helper should reject unsupported implementations")
-	}
-}
-
-func TestAgentStreamUsesProviderStreamingAndRecordsAssistantMemory(t *testing.T) {
-	var sawRequest bool
-	fakeStream = func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error) {
-		sawRequest = true
-		if req.Prompt != "stream the answer" {
-			t.Fatalf("Prompt = %q, want stream the answer", req.Prompt)
-		}
-		if len(req.Messages) != 1 || req.Messages[0].Role != "user" || req.Messages[0].Content != "stream the answer" {
-			t.Fatalf("Messages = %#v, want current user turn in memory", req.Messages)
-		}
-		return &sliceStream{chunks: []string{"hel", "lo"}}, nil
-	}
-	defer func() { fakeStream = nil }()
-
-	a := newTestAgent(Name("provider-stream"))
-	stream, err := a.Stream(context.Background(), "stream the answer")
-	if err != nil {
-		t.Fatalf("Stream: %v", err)
-	}
-
-	var reply string
-	for {
-		chunk, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv: %v", err)
-		}
-		reply += chunk.Reply
-	}
-	if err := stream.Close(); err != nil {
-		t.Fatalf("Close: %v", err)
-	}
-	if !sawRequest {
-		t.Fatal("provider Stream was not called")
-	}
-	if reply != "hello" {
-		t.Fatalf("reply = %q, want hello", reply)
-	}
-	got := a.mem.Messages()
-	if len(got) != 2 || got[0].Role != "user" || got[0].Content != "stream the answer" || got[1].Role != "assistant" || got[1].Content != "hello" {
-		t.Fatalf("memory = %#v, want user turn and streamed assistant reply", got)
-	}
-}
-
-func TestResumeStreamAskDoesNotReplayCompletedTool(t *testing.T) {
-	ctx := context.Background()
-	cp := flow.StoreCheckpoint(store.NewStore(), "stream-resume-agent")
-	toolRuns := 0
-	first := true
-	fakeGen = func(ctx context.Context, opts ai.Options, req *ai.Request) (*ai.Response, error) {
-		if opts.ToolHandler != nil {
-			res := opts.ToolHandler(ctx, ai.ToolCall{ID: "call-1", Name: "charge", Input: map[string]any{"order": "42"}})
-			if res.Content != "charged" {
-				t.Fatalf("tool result = %q, want charged", res.Content)
-			}
-		}
-		if first {
-			first = false
-			return nil, errors.New("stream disconnected after tool")
-		}
-		return &ai.Response{Reply: "finished from streamed checkpoint"}, nil
-	}
-	defer func() { fakeGen = nil }()
-
-	a := newTestAgent(Name("stream-resume-agent"), WithCheckpoint(cp),
-		WithTool("charge", "charge once", nil, func(context.Context, map[string]any) (string, error) {
-			toolRuns++
-			return "charged", nil
-		}))
-	stream, err := a.StreamAsk(ctx, "charge order 42")
-	if err != nil {
-		t.Fatalf("StreamAsk: %v", err)
-	}
-	for {
-		_, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			break
-		}
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after failed StreamAsk = %d, want 1", toolRuns)
-	}
-	runs, err := Pending(ctx, a)
-	if err != nil {
-		t.Fatalf("Pending: %v", err)
-	}
-	if len(runs) != 1 {
-		t.Fatalf("Pending returned %d runs, want 1", len(runs))
-	}
-
-	resumed, err := ResumeStreamAsk(ctx, a, runs[0].ID)
-	if err != nil {
-		t.Fatalf("ResumeStreamAsk: %v", err)
-	}
-	var toolEvents int
-	var done *Response
-	for {
-		event, err := resumed.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("resumed Recv: %v", err)
-		}
-		if event.Type == StreamEventToolStart || event.Type == StreamEventToolEnd {
-			toolEvents++
-		}
-		if event.Type == StreamEventDone {
-			done = event.Response
-		}
-	}
-	if toolRuns != 1 {
-		t.Fatalf("tool executions after ResumeStreamAsk = %d, want completed tool was not replayed", toolRuns)
-	}
-	if toolEvents != 2 {
-		t.Fatalf("resumed tool events = %d, want start/end for replayed checkpoint result", toolEvents)
-	}
-	if done == nil || done.Reply != "finished from streamed checkpoint" || done.RunID != runs[0].ID {
-		t.Fatalf("done response = %#v", done)
-	}
-}
-
-func TestAgentStreamDoesNotRecordUserWhenProviderStreamingUnsupported(t *testing.T) {
-	fakeStream = func(ctx context.Context, opts ai.Options, req *ai.Request) (ai.Stream, error) {
-		if len(req.Messages) == 0 || req.Messages[len(req.Messages)-1].Role != "user" || req.Messages[len(req.Messages)-1].Content != "stream fallback" {
-			t.Fatalf("stream request messages = %+v, want pending user message", req.Messages)
-		}
-		return nil, ai.ErrStreamingUnsupported
-	}
-	defer func() { fakeStream = nil }()
-
-	mem := NewInMemory(8)
-	a := newTestAgent(Name("stream-fallback"), WithMemory(mem), WithTool("echo", "echo text", nil, func(context.Context, map[string]any) (string, error) {
-		return "ok", nil
-	}))
-
-	_, err := a.Stream(context.Background(), "stream fallback")
-	if !errors.Is(err, ai.ErrStreamingUnsupported) {
-		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
-	}
-	if got := mem.Messages(); len(got) != 0 {
-		t.Fatalf("memory after unsupported stream = %+v, want no recorded messages", got)
-	}
-}
-
-type unsupportedAgent struct{}
-
-func (unsupportedAgent) Name() string                                      { return "unsupported" }
-func (unsupportedAgent) Init(...Option)                                    {}
-func (unsupportedAgent) Options() Options                                  { return Options{} }
-func (unsupportedAgent) Ask(context.Context, string) (*Response, error)    { return nil, nil }
-func (unsupportedAgent) Stream(context.Context, string) (ai.Stream, error) { return nil, nil }
-func (unsupportedAgent) Run() error                                        { return nil }
-func (unsupportedAgent) Stop() error                                       { return nil }
-func (unsupportedAgent) String() string                                    { return "unsupported" }

agent/text_tool_calls.go

@@ -1,407 +0,0 @@
-package agent
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"html"
-	"regexp"
-	"strings"
-
-	"go-micro.dev/v6/ai"
-)
-
-var fencedJSONBlock = regexp.MustCompile("(?s)```(?:json)?\\s*(.*?)\\s*```")
-var taggedToolCallBlock = regexp.MustCompile(`(?s)<[^<>]*(?:tool_call|tool_calls|function=)[^<>]*>(.*?)</[^<>]*>`)
-var singleTaggedToolCall = regexp.MustCompile(`(?s)<(tool_call\b[^<>]*|[^<>]*function\s*=[^<>]*)>(.*?)</[^<>]*>`)
-var taggedToolNameAttr = regexp.MustCompile(`(?i)(?:function|name|tool)\s*=\s*["\']?([^"\'\s>]+)`)
-
-type textToolCall struct {
-	ID        string         `json:"id"`
-	Name      string         `json:"name"`
-	Tool      string         `json:"tool"`
-	Input     map[string]any `json:"input"`
-	Arguments any            `json:"arguments"`
-	Function  *textToolCall  `json:"function"`
-}
-
-// executeTextToolCalls is a compatibility fallback for providers that return a
-// tool call as text JSON instead of a structured tool_calls field. It only runs
-// calls whose names match the tools offered to the model, so ordinary JSON
-// answers are left untouched.
-func (a *agentImpl) executeTextToolCalls(ctx context.Context, reply string, tools []ai.Tool) ([]ai.ToolCall, string, bool) {
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) == 0 {
-		return nil, "", false
-	}
-
-	handler := a.toolHandler()
-	results := make([]string, 0, len(calls))
-	for i := range calls {
-		result := handler(ctx, calls[i])
-		calls[i].Result = result.Content
-		if result.Refused != "" {
-			calls[i].Error = result.Refused
-		}
-		if result.Content != "" {
-			results = append(results, result.Content)
-		}
-	}
-	return calls, strings.Join(results, "\n"), true
-}
-
-// executeAdditionalTextToolCalls runs text-encoded tool calls that accompany a
-// structured tool_calls response. Some OpenAI-compatible providers can mix the
-// two forms in a single assistant turn: for example, emitting a native
-// conformance_echo call while rendering a follow-up guarded delegate call as
-// <tool_call name="delegate">...</tool_call> text. Keep this fallback additive
-// and de-duplicate calls already represented in the structured tool_calls list.
-func (a *agentImpl) executeAdditionalTextToolCalls(ctx context.Context, reply string, tools []ai.Tool, existing []ai.ToolCall) ([]ai.ToolCall, string, bool) {
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) == 0 {
-		return nil, "", false
-	}
-
-	seen := map[string]bool{}
-	for _, call := range existing {
-		seen[textToolCallKey(call)] = true
-	}
-
-	handler := a.toolHandler()
-	out := make([]ai.ToolCall, 0, len(calls))
-	results := make([]string, 0, len(calls))
-	for i := range calls {
-		if seen[textToolCallKey(calls[i])] {
-			continue
-		}
-		result := handler(ctx, calls[i])
-		calls[i].Result = result.Content
-		if result.Refused != "" {
-			calls[i].Error = result.Refused
-		}
-		if result.Content != "" {
-			results = append(results, result.Content)
-		}
-		out = append(out, calls[i])
-	}
-	return out, strings.Join(results, "\n"), len(out) > 0
-}
-
-func textToolCallKey(call ai.ToolCall) string {
-	b, _ := json.Marshal(call.Input)
-	return call.Name + "\x00" + string(b)
-}
-
-func parseTextToolCalls(text string, tools []ai.Tool) []ai.ToolCall {
-	text = html.UnescapeString(text)
-	allowed := textToolNames(tools)
-	if len(allowed) == 0 {
-		return nil
-	}
-
-	if calls := decodeTaggedTextToolCalls(text, allowed); len(calls) > 0 {
-		return calls
-	}
-	if calls := decodeFunctionTextToolCalls(text, allowed); len(calls) > 0 {
-		return calls
-	}
-	for _, candidate := range jsonCandidates(text) {
-		if calls := decodeTextToolCalls(candidate, allowed); len(calls) > 0 {
-			return calls
-		}
-	}
-	return nil
-}
-
-func textToolNames(tools []ai.Tool) map[string]string {
-	allowed := map[string]string{}
-	for _, tool := range tools {
-		addTextToolName(allowed, tool.Name, tool.Name)
-		if tool.OriginalName != "" {
-			addTextToolName(allowed, tool.OriginalName, tool.Name)
-		}
-	}
-	return allowed
-}
-
-func addTextToolName(allowed map[string]string, name, canonical string) {
-	if name == "" || canonical == "" {
-		return
-	}
-	allowed[name] = canonical
-	// Some OpenAI-compatible models describe an idempotent Add endpoint as a
-	// creation action and emit the otherwise-correct service tool with a Create
-	// suffix in text-only tool-call markup. Keep the fallback bounded by the
-	// offered service tool prefix so ordinary unknown tools remain ignored.
-	for _, suffix := range []string{"_Add", ".Add"} {
-		if strings.HasSuffix(name, suffix) {
-			allowed[strings.TrimSuffix(name, suffix)+strings.Replace(suffix, "Add", "Create", 1)] = canonical
-		}
-	}
-}
-
-func jsonCandidates(text string) []string {
-	trimmed := strings.TrimSpace(text)
-	var out []string
-	if trimmed != "" {
-		out = append(out, trimmed)
-	}
-	for _, match := range fencedJSONBlock.FindAllStringSubmatch(text, -1) {
-		if len(match) > 1 {
-			out = append(out, strings.TrimSpace(match[1]))
-		}
-	}
-	for _, match := range taggedToolCallBlock.FindAllStringSubmatch(text, -1) {
-		if len(match) > 1 {
-			out = append(out, strings.TrimSpace(match[1]))
-		}
-	}
-	if start, end := strings.IndexAny(text, "[{"), strings.LastIndexAny(text, "]}"); start >= 0 && end > start {
-		out = append(out, strings.TrimSpace(text[start:end+1]))
-	}
-	return out
-}
-
-func decodeTextToolCalls(candidate string, allowed map[string]string) []ai.ToolCall {
-	var root any
-	if err := json.Unmarshal([]byte(candidate), &root); err != nil {
-		return nil
-	}
-	return collectTextToolCalls(root, allowed)
-}
-
-func collectTextToolCalls(v any, allowed map[string]string) []ai.ToolCall {
-	switch x := v.(type) {
-	case []any:
-		var out []ai.ToolCall
-		for _, item := range x {
-			out = append(out, collectTextToolCalls(item, allowed)...)
-		}
-		return out
-	case map[string]any:
-		if nested, ok := firstNestedToolCalls(x); ok {
-			return collectTextToolCalls(nested, allowed)
-		}
-		call := mapToTextToolCall(x)
-		name, input := textToolCallNameAndInput(call)
-		if name == "" || allowed[name] == "" || input == nil {
-			return nil
-		}
-		id := call.ID
-		if id == "" {
-			id = fmt.Sprintf("text-call-%s", strings.ReplaceAll(name, ".", "_"))
-		}
-		return []ai.ToolCall{{ID: id, Name: allowed[name], Input: input}}
-	default:
-		return nil
-	}
-}
-
-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) {
-		if len(match) < 3 {
-			continue
-		}
-		tag, body := match[1], strings.TrimSpace(match[2])
-		if calls := decodeTextToolCalls(body, allowed); len(calls) > 0 {
-			out = append(out, calls...)
-			continue
-		}
-		if calls := decodeTaggedTextToolCalls(body, allowed); len(calls) > 0 {
-			out = append(out, calls...)
-			continue
-		}
-		name := taggedToolName(tag)
-		if name == "" || allowed[name] == "" {
-			continue
-		}
-		var input map[string]any
-		if err := json.Unmarshal([]byte(body), &input); err != nil || input == nil {
-			continue
-		}
-		out = append(out, ai.ToolCall{
-			ID:    fmt.Sprintf("text-call-%s", strings.ReplaceAll(name, ".", "_")),
-			Name:  allowed[name],
-			Input: input,
-		})
-	}
-	return out
-}
-
-func taggedToolName(tag string) string {
-	match := taggedToolNameAttr.FindStringSubmatch(tag)
-	if len(match) < 2 {
-		return ""
-	}
-	return strings.Trim(match[1], `"'`)
-}
-
-func decodeFunctionTextToolCalls(text string, allowed map[string]string) []ai.ToolCall {
-	var out []ai.ToolCall
-	for alias, canonical := range allowed {
-		for _, body := range functionCallBodies(text, alias) {
-			var input map[string]any
-			if err := json.Unmarshal([]byte(body), &input); err != nil || input == nil {
-				continue
-			}
-			out = append(out, ai.ToolCall{
-				ID:    fmt.Sprintf("text-call-%s", strings.ReplaceAll(alias, ".", "_")),
-				Name:  canonical,
-				Input: input,
-			})
-		}
-	}
-	return out
-}
-
-func functionCallBodies(text, name string) []string {
-	if name == "" {
-		return nil
-	}
-	var bodies []string
-	for searchFrom := 0; searchFrom < len(text); {
-		idx := strings.Index(text[searchFrom:], name)
-		if idx < 0 {
-			break
-		}
-		start := searchFrom + idx
-		open := start + len(name)
-		if !isFunctionCallBoundary(text, start, open) {
-			searchFrom = start + len(name)
-			continue
-		}
-		bodyStart := open + 1
-		bodyEnd, ok := balancedJSONObjectEnd(text, bodyStart)
-		if !ok {
-			searchFrom = bodyStart
-			continue
-		}
-		bodies = append(bodies, strings.TrimSpace(text[bodyStart:bodyEnd]))
-		searchFrom = bodyEnd + 1
-	}
-	return bodies
-}
-
-func isFunctionCallBoundary(text string, start, open int) bool {
-	if open >= len(text) || text[open] != '(' {
-		return false
-	}
-	if start > 0 {
-		prev := text[start-1]
-		if prev == '_' || prev == '.' || prev == '-' || prev == '$' || ('0' <= prev && prev <= '9') || ('A' <= prev && prev <= 'Z') || ('a' <= prev && prev <= 'z') {
-			return false
-		}
-	}
-	for i := open + 1; i < len(text); i++ {
-		switch text[i] {
-		case ' ', '\n', '\r', '\t':
-			continue
-		case '{':
-			return true
-		default:
-			return false
-		}
-	}
-	return false
-}
-
-func balancedJSONObjectEnd(text string, start int) (int, bool) {
-	for start < len(text) {
-		switch text[start] {
-		case ' ', '\n', '\r', '\t':
-			start++
-		case '{':
-			depth := 0
-			inString := false
-			escaped := false
-			for i := start; i < len(text); i++ {
-				c := text[i]
-				if inString {
-					if escaped {
-						escaped = false
-					} else if c == '\\' {
-						escaped = true
-					} else if c == '"' {
-						inString = false
-					}
-					continue
-				}
-				switch c {
-				case '"':
-					inString = true
-				case '{':
-					depth++
-				case '}':
-					depth--
-					if depth == 0 {
-						for j := i + 1; j < len(text); j++ {
-							switch text[j] {
-							case ' ', '\n', '\r', '\t':
-								continue
-							case ')':
-								return i + 1, true
-							default:
-								return 0, false
-							}
-						}
-					}
-				}
-			}
-			return 0, false
-		default:
-			return 0, false
-		}
-	}
-	return 0, false
-}
-
-func firstNestedToolCalls(m map[string]any) (any, bool) {
-	for _, key := range []string{"tool_calls", "toolCalls", "calls"} {
-		if v, ok := m[key]; ok {
-			return v, true
-		}
-	}
-	return nil, false
-}
-
-func mapToTextToolCall(m map[string]any) textToolCall {
-	b, _ := json.Marshal(m)
-	var call textToolCall
-	_ = json.Unmarshal(b, &call)
-	return call
-}

agent/text_tool_calls_test.go

@@ -1,148 +0,0 @@
-package agent
-
-import (
-	"testing"
-
-	"go-micro.dev/v6/ai"
-)
-
-func TestParseTextToolCallsMiniMaxTaggedMarkup(t *testing.T) {
-	tools := []ai.Tool{{Name: "task_TaskService_Add"}}
-	reply := `<tool_calls>
-<tool_call>{"name":"task_TaskService_Add","arguments":{"title":"Design"}}</tool_call>
-<tool_call>{"name":"task_TaskService_Add","arguments":{"title":"Build"}}</tool_call>
-<tool_call>{"name":"task_TaskService_Add","arguments":{"title":"Ship"}}</tool_call>
-</tool_calls>`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 3 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 3: %+v", len(calls), calls)
-	}
-	for i, want := range []string{"Design", "Build", "Ship"} {
-		if calls[i].Name != "task_TaskService_Add" {
-			t.Fatalf("call %d name = %q, want task_TaskService_Add", i, calls[i].Name)
-		}
-		if got := calls[i].Input["title"]; got != want {
-			t.Fatalf("call %d title = %v, want %q", i, got, want)
-		}
-	}
-}
-
-func TestParseTextToolCallsFunctionTaggedMarkup(t *testing.T) {
-	tools := []ai.Tool{{Name: "task_TaskService_Add"}}
-	reply := `<function=task_TaskService_Add>{"title":"Design"}</function>`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if got := calls[0].Input["title"]; got != "Design" {
-		t.Fatalf("title = %v, want Design", got)
-	}
-}
-
-func TestParseTextToolCallsCreateAliasForAddTool(t *testing.T) {
-	tools := []ai.Tool{{Name: "task_TaskService_Add", OriginalName: "task.TaskService.Add"}}
-	reply := `<tool_call>{"name":"task_TaskService_Create","arguments":{"title":"Design"}}</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 != "task_TaskService_Add" {
-		t.Fatalf("call name = %q, want canonical task_TaskService_Add", calls[0].Name)
-	}
-	if got := calls[0].Input["title"]; got != "Design" {
-		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)
-	}
-}
-
-func TestParseTextToolCallsTaggedMarkupWithSpacedNameAttribute(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `<tool_call name = "delegate">{"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["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}
-
-func TestParseTextToolCallsHTMLEscapedTaggedMarkup(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `&lt;tool_call name=&quot;delegate&quot;&gt;{"task":"summarize the conformance marker","to":"blocked-reviewer"}&lt;/tool_call&gt;`
-
-	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)
-	}
-}
-
-func TestParseTextToolCallsFunctionCallSyntax(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `I will now call delegate({"task":"summarize the conformance marker","to":"blocked-reviewer"}) before answering.`
-
-	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)
-	}
-}
-
-func TestParseTextToolCallsFunctionCallSyntaxHandlesNestedJSON(t *testing.T) {
-	tools := []ai.Tool{{Name: "delegate"}}
-	reply := `delegate({
-		"task":"summarize the {escaped} marker",
-		"meta":{"note":"paren ) and brace } in string"},
-		"to":"blocked-reviewer"
-	})`
-
-	calls := parseTextToolCalls(reply, tools)
-	if len(calls) != 1 {
-		t.Fatalf("parseTextToolCalls returned %d calls, want 1: %+v", len(calls), calls)
-	}
-	if got := calls[0].Input["task"]; got != "summarize the {escaped} marker" {
-		t.Fatalf("task = %v, want nested JSON-safe task", got)
-	}
-	if got := calls[0].Input["to"]; got != "blocked-reviewer" {
-		t.Fatalf("to = %v, want blocked-reviewer", got)
-	}
-}

ai/README.md

@@ -300,20 +300,6 @@ Default base URL: `https://api.atlascloud.ai`
 
 Atlas Cloud is an enterprise AI infrastructure platform offering high-performance LLM APIs. It exposes an OpenAI-compatible chat completions endpoint with tool calling support.
 
-### MiniMax
-
-```go
-m := ai.New("minimax",
-    ai.WithAPIKey("your-key"),
-    ai.WithModel("MiniMax-M3"), // default
-)
-```
-
-Default model: `MiniMax-M3`
-Default base URL: `https://api.minimax.io`
-
-MiniMax offers its flagship MiniMax-M3 model via an OpenAI-compatible chat completions endpoint.
-
 ## Auto-Detection
 
 Use `AutoDetectProvider()` to detect the provider from a base URL:

ai/anthropic/anthropic.go

@@ -2,7 +2,6 @@
 package anthropic
 
 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
@@ -18,7 +17,6 @@ func init() {
 	ai.Register("anthropic", func(opts ...ai.Option) ai.Model {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("anthropic")
 }
 
 // Provider implements the ai.Model interface for Anthropic Claude
@@ -79,7 +77,7 @@ 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),
 	}
@@ -126,7 +124,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,
 		}
@@ -158,113 +156,9 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	return resp, nil
 }
 
-// Stream generates a streaming response from Anthropic's Messages SSE API.
+// Stream generates a streaming response (not yet implemented)
 func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	apiReq := map[string]any{
-		"model":      p.opts.Model,
-		"max_tokens": anthropicMaxTokens(p.opts),
-		"system":     req.SystemPrompt,
-		"messages":   threadAnthropicMessages(req),
-		"stream":     true,
-	}
-	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/messages"
-	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("x-api-key", p.opts.APIKey)
-	httpReq.Header.Set("anthropic-version", "2023-06-01")
-
-	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 &streamReader{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-type streamReader struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *streamReader) Recv() (*ai.Response, error) {
-	for s.scanner.Scan() {
-		line := strings.TrimSpace(s.scanner.Text())
-		if line == "" || strings.HasPrefix(line, ":") || strings.HasPrefix(line, "event:") {
-			continue
-		}
-		if !strings.HasPrefix(line, "data:") {
-			continue
-		}
-		data := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
-		var chunk struct {
-			Type  string `json:"type"`
-			Delta struct {
-				Type string `json:"type"`
-				Text string `json:"text"`
-			} `json:"delta"`
-			Message struct {
-				Usage struct {
-					InputTokens  int `json:"input_tokens"`
-					OutputTokens int `json:"output_tokens"`
-				} `json:"usage"`
-			} `json:"message"`
-			Usage *struct {
-				InputTokens  int `json:"input_tokens"`
-				OutputTokens int `json:"output_tokens"`
-			} `json:"usage"`
-		}
-		if err := json.Unmarshal([]byte(data), &chunk); err != nil {
-			return nil, fmt.Errorf("failed to parse stream chunk: %w", err)
-		}
-		switch chunk.Type {
-		case "content_block_delta":
-			if chunk.Delta.Type == "text_delta" && chunk.Delta.Text != "" {
-				return &ai.Response{Reply: chunk.Delta.Text}, nil
-			}
-		case "message_start":
-			if chunk.Message.Usage.InputTokens > 0 || chunk.Message.Usage.OutputTokens > 0 {
-				return &ai.Response{Usage: usage(chunk.Message.Usage.InputTokens, chunk.Message.Usage.OutputTokens)}, nil
-			}
-		case "message_delta":
-			if chunk.Usage != nil {
-				return &ai.Response{Usage: usage(chunk.Usage.InputTokens, chunk.Usage.OutputTokens)}, nil
-			}
-		case "message_stop":
-			return nil, io.EOF
-		case "error":
-			return nil, fmt.Errorf("anthropic stream error: %s", data)
-		}
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *streamReader) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
-}
-
-func usage(input, output int) ai.Usage {
-	return ai.Usage{InputTokens: input, OutputTokens: output, TotalTokens: input + output}
+	return nil, fmt.Errorf("%w: anthropic provider", ai.ErrStreamingUnsupported)
 }
 
 // callAPI makes an HTTP request to the Anthropic API
@@ -297,7 +191,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 	// Read response
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	// Parse response
@@ -374,6 +268,7 @@ 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.
@@ -387,10 +282,3 @@ func threadAnthropicMessages(req *ai.Request) []map[string]any {
 	}
 	return msgs
 }
-
-func anthropicMaxTokens(o ai.Options) int {
-	if o.MaxTokens > 0 {
-		return o.MaxTokens
-	}
-	return 8192
-}

ai/anthropic/anthropic_test.go

@@ -3,10 +3,6 @@ package anthropic
 import (
 	"context"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -85,67 +81,15 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }
 
-func TestProvider_Stream(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/messages" {
-			t.Fatalf("path = %q, want /v1/messages", r.URL.Path)
-		}
-		if got := r.Header.Get("Accept"); got != "text/event-stream" {
-			t.Fatalf("Accept = %q, want text/event-stream", got)
-		}
-		if got := r.Header.Get("x-api-key"); got != "test-key" {
-			t.Fatalf("x-api-key = %q, want test-key", got)
-		}
-		body, _ := io.ReadAll(r.Body)
-		if !strings.Contains(string(body), `"stream":true`) {
-			t.Fatalf("request body %s does not enable streaming", string(body))
-		}
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("event: message_start\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_start","message":{"usage":{"input_tokens":2}}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: content_block_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"hel"}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: content_block_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"lo"}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: message_delta\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_delta","usage":{"output_tokens":3}}` + "\n\n"))
-		_, _ = w.Write([]byte("event: message_stop\n"))
-		_, _ = w.Write([]byte(`data: {"type":"message_stop"}` + "\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	p := NewProvider()
 
 	req := &ai.Request{
 		Prompt: "Hello",
 	}
 
-	stream, err := p.Stream(context.Background(), req)
-	if err != nil {
-		t.Fatalf("Stream failed: %v", err)
-	}
-	defer stream.Close()
-
-	var reply strings.Builder
-	var usage ai.Usage
-	for {
-		chunk, err := stream.Recv()
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			t.Fatalf("Recv failed: %v", err)
-		}
-		reply.WriteString(chunk.Reply)
-		if chunk.Usage.TotalTokens > 0 {
-			usage = chunk.Usage
-		}
-	}
-	if got := reply.String(); got != "hello" {
-		t.Fatalf("reply = %q, want hello", got)
-	}
-	if usage.TotalTokens != 3 {
-		t.Fatalf("usage = %+v, want total 3", usage)
+	_, err := p.Stream(context.Background(), req)
+	if !errors.Is(err, ai.ErrStreamingUnsupported) {
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }

ai/atlascloud/atlascloud.go

@@ -20,15 +20,12 @@
 package atlascloud
 
 import (
-	"bufio"
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"strings"
 	"time"
 
@@ -45,7 +42,6 @@ func init() {
 	ai.RegisterVideo("atlascloud", func(opts ...ai.Option) ai.VideoModel {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("atlascloud")
 }
 
 // Provider implements the ai.Model interface for Atlas Cloud.
@@ -53,28 +49,12 @@ type Provider struct {
 	opts ai.Options
 }
 
-type atlasToolCall struct {
-	ID       string `json:"id"`
-	Type     string `json:"type"`
-	Function struct {
-		Name      string `json:"name"`
-		Arguments string `json:"arguments"`
-	} `json:"function"`
-}
-
 // NewProvider creates a new Atlas Cloud provider.
 func NewProvider(opts ...ai.Option) *Provider {
 	options := ai.NewOptions(opts...)
 
 	if options.Model == "" {
-		// Allow the chat model to be selected via the ATLASCLOUD_MODEL env var
-		// (e.g. to run CI conformance against a stronger tool-use model) without
-		// a code change; fall back to a sensible default otherwise.
-		if m := os.Getenv("ATLASCLOUD_MODEL"); m != "" {
-			options.Model = m
-		} else {
-			options.Model = "deepseek-ai/DeepSeek-V3-0324"
-		}
+		options.Model = "deepseek-ai/DeepSeek-V3-0324"
 	}
 	if options.BaseURL == "" {
 		options.BaseURL = "https://api.atlascloud.ai"
@@ -94,9 +74,20 @@ func (p *Provider) Options() ai.Options { return p.opts }
 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)
-	textToolPrompt := atlascloudMinimaxTextToolPrompt(p.opts.Model, req.Tools)
+	var tools []map[string]any
+	for _, t := range req.Tools {
+		tools = append(tools, map[string]any{
+			"type": "function",
+			"function": map[string]any{
+				"name":        t.Name,
+				"description": t.Description,
+				"parameters": map[string]any{
+					"type":       "object",
+					"properties": t.Properties,
+				},
+			},
+		})
+	}
 
 	messages := []map[string]any{
 		{"role": "system", "content": req.SystemPrompt},
@@ -107,36 +98,19 @@ 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,
 		"messages": messages,
 	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
-	}
 
 	if len(tools) > 0 {
 		apiReq["tools"] = tools
 	}
 
-	resp, rawMessage, err := p.callAPI(ctx, "chat", apiReq)
+	resp, rawMessage, err := p.callAPI(ctx, apiReq)
 	if err != nil {
-		if atlascloudShouldRetryMinimaxCompat(err, compatTools) {
-			apiReq["tools"] = compatTools
-			resp, rawMessage, err = p.callAPI(ctx, "chat-minimax-compat", apiReq)
-		}
-		if atlascloudShouldRetryMinimaxTextTools(err, textToolPrompt) {
-			delete(apiReq, "tools")
-			apiReq["messages"] = append(messages, map[string]any{"role": "system", "content": textToolPrompt})
-			resp, rawMessage, err = p.callAPI(ctx, "chat-minimax-text-tools", apiReq)
-		}
-		if err != nil {
-			return nil, err
-		}
+		return nil, err
 	}
 
 	if len(resp.ToolCalls) == 0 {
@@ -144,223 +118,40 @@ func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.Gen
 	}
 
 	if p.opts.ToolHandler != nil {
-		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 attempt := 0; len(pendingToolCalls) > 0 && attempt < 4; attempt++ {
-			for _, tc := range pendingToolCalls {
-				result := p.opts.ToolHandler(ctx, tc)
-				if result.Refused != "" {
-					tc.Error = result.Refused
-				}
-				if 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,
-				})
-			}
-
-			followUpReq := map[string]any{
-				"model":    p.opts.Model,
-				"messages": followUpMessages,
-			}
-			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")
-					followUpReq["messages"] = atlascloudFollowUpMessagesWithoutTools(p.opts.Model, followUpMessages)
-					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
-			}
-
+		for _, tc := range resp.ToolCalls {
+			content := p.opts.ToolHandler(ctx, tc).Content
 			followUpMessages = append(followUpMessages, map[string]any{
-				"role":       "assistant",
-				"content":    followUpRawMessage["content"],
-				"tool_calls": followUpRawMessage["tool_calls"],
+				"role":         "tool",
+				"tool_call_id": tc.ID,
+				"content":      content,
 			})
-			pendingToolCalls = followUpResp.ToolCalls
+		}
+
+		followUpReq := map[string]any{
+			"model":    p.opts.Model,
+			"messages": followUpMessages,
+		}
+
+		followUpResp, _, err := p.callAPI(ctx, followUpReq)
+		if err == nil && followUpResp.Reply != "" {
+			resp.Answer = followUpResp.Reply
 		}
 	}
 
 	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) {
-	if len(req.Tools) > 0 {
-		return nil, fmt.Errorf("%w: atlascloud streaming does not expose tools", ai.ErrStreamingUnsupported)
-	}
-
-	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
+	return nil, fmt.Errorf("%w: atlascloud provider", ai.ErrStreamingUnsupported)
 }
 
-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()
-}
-
-type atlascloudAPIError struct {
-	Status  string
-	Code    int
-	Retry   time.Duration
-	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 (e *atlascloudAPIError) StatusCode() int {
-	if e == nil {
-		return 0
-	}
-	return e.Code
-}
-
-func (e *atlascloudAPIError) RetryAfter() time.Duration {
-	if e == nil {
-		return 0
-	}
-	return e.Retry
-}
-
-func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any) (*ai.Response, map[string]any, error) {
+func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {
 	reqBody, err := json.Marshal(req)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to marshal request: %w", err)
@@ -383,19 +174,20 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		retryAfter := time.Duration(0)
-		var retryErr interface{ RetryAfter() time.Duration }
-		if errors.As(ai.NewHTTPError(httpResp, respBody), &retryErr) {
-			retryAfter = retryErr.RetryAfter()
-		}
-		return nil, nil, &atlascloudAPIError{Status: httpResp.Status, Code: httpResp.StatusCode, Retry: retryAfter, Phase: phase, Summary: atlascloudRequestSummary(req), Body: string(respBody)}
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {
 		Choices []struct {
 			Message struct {
-				Content   string          `json:"content"`
-				ToolCalls []atlasToolCall `json:"tool_calls"`
+				Content   string `json:"content"`
+				ToolCalls []struct {
+					ID       string `json:"id"`
+					Function struct {
+						Name      string `json:"name"`
+						Arguments string `json:"arguments"`
+					} `json:"function"`
+				} `json:"tool_calls"`
 			} `json:"message"`
 		} `json:"choices"`
 	}
@@ -427,237 +219,12 @@ func (p *Provider) callAPI(ctx context.Context, phase string, req map[string]any
 
 	rawMessage := map[string]any{
 		"content":    choice.Message.Content,
-		"tool_calls": normalizeAtlasCloudToolCalls(choice.Message.ToolCalls),
+		"tool_calls": choice.Message.ToolCalls,
 	}
 
 	return response, rawMessage, nil
 }
 
-func atlascloudFollowUpMessagesWithoutTools(model string, messages []map[string]any) []map[string]any {
-	if !atlascloudIsMinimaxModel(model) {
-		return messages
-	}
-	out := make([]map[string]any, 0, len(messages)+1)
-	for _, msg := range messages {
-		role, _ := msg["role"].(string)
-		switch role {
-		case "assistant":
-			converted := map[string]any{"role": "assistant"}
-			if content, _ := msg["content"].(string); content != "" {
-				converted["content"] = content
-			} else if calls, ok := msg["tool_calls"]; ok {
-				converted["content"] = "Tool call requested: " + atlascloudToolCallsText(calls)
-			} else {
-				converted["content"] = ""
-			}
-			out = append(out, converted)
-		case "tool":
-			toolID, _ := msg["tool_call_id"].(string)
-			content, _ := msg["content"].(string)
-			if toolID != "" {
-				content = "Tool result for " + toolID + ": " + content
-			} else {
-				content = "Tool result: " + content
-			}
-			out = append(out, map[string]any{"role": "user", "content": content})
-		default:
-			copyMsg := make(map[string]any, len(msg))
-			for k, v := range msg {
-				copyMsg[k] = v
-			}
-			out = append(out, copyMsg)
-		}
-	}
-	return out
-}
-
-func atlascloudToolCallsText(calls any) string {
-	b, err := json.Marshal(calls)
-	if err != nil {
-		return fmt.Sprint(calls)
-	}
-	return string(b)
-}
-
-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 atlascloudMinimaxTextToolPrompt(model string, input []ai.Tool) string {
-	if !atlascloudIsMinimaxModel(model) || len(input) == 0 {
-		return ""
-	}
-	names := make([]string, 0, len(input))
-	for _, tool := range input {
-		if tool.Name != "" {
-			names = append(names, tool.Name)
-		}
-	}
-	if len(names) == 0 {
-		return ""
-	}
-	return "AtlasCloud/minimax text-tool compatibility: the native tools payload was rejected. " +
-		"Call exactly one needed tool from this list by emitting exactly <tool_call name=\"tool_name\">{...}</tool_call>: " +
-		strings.Join(names, ", ") + ". Do not answer in prose instead of emitting the tag."
-}
-
-func atlascloudShouldRetryMinimaxTextTools(err error, prompt string) bool {
-	if prompt == "" {
-		return false
-	}
-	var apiErr *atlascloudAPIError
-	return errors.As(err, &apiErr) && apiErr.StatusCode() == http.StatusBadRequest
-}
-
-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 {
-		tools = append(tools, map[string]any{
-			"type": "function",
-			"function": map[string]any{
-				"name":        t.Name,
-				"description": t.Description,
-				"parameters": map[string]any{
-					"type":       "object",
-					"properties": normalizeAtlasCloudSchema(t.Properties),
-				},
-			},
-		})
-	}
-	return tools
-}
-
-func normalizeAtlasCloudSchema(schema map[string]any) map[string]any {
-	if schema == nil {
-		return nil
-	}
-	out := make(map[string]any, len(schema))
-	for k, v := range schema {
-		out[k] = normalizeAtlasCloudSchemaValue(v)
-	}
-	return out
-}
-
-func normalizeAtlasCloudSchemaValue(v any) any {
-	switch val := v.(type) {
-	case map[string]any:
-		out := make(map[string]any, len(val)+1)
-		for k, nested := range val {
-			out[k] = normalizeAtlasCloudSchemaValue(nested)
-		}
-		if typ, _ := out["type"].(string); typ == "array" {
-			if _, ok := out["items"]; !ok {
-				out["items"] = map[string]any{}
-			}
-		}
-		return out
-	case []any:
-		out := make([]any, len(val))
-		for i, nested := range val {
-			out[i] = normalizeAtlasCloudSchemaValue(nested)
-		}
-		return out
-	default:
-		return v
-	}
-}
-
-func normalizeAtlasCloudToolCalls(toolCalls []atlasToolCall) []map[string]any {
-	out := make([]map[string]any, 0, len(toolCalls))
-	for _, tc := range toolCalls {
-		toolType := tc.Type
-		if toolType == "" {
-			toolType = "function"
-		}
-		out = append(out, map[string]any{
-			"id":   tc.ID,
-			"type": toolType,
-			"function": map[string]any{
-				"name":      tc.Function.Name,
-				"arguments": tc.Function.Arguments,
-			},
-		})
-	}
-	return out
-}
-
-func atlascloudRequestSummary(req map[string]any) string {
-	parts := []string{}
-	if model, ok := req["model"].(string); ok && model != "" {
-		parts = append(parts, "model="+model)
-	}
-	if messages, ok := req["messages"].([]map[string]any); ok {
-		parts = append(parts, fmt.Sprintf("messages=%d", len(messages)))
-		if len(messages) > 0 {
-			last := messages[len(messages)-1]
-			if role, ok := last["role"].(string); ok && role != "" {
-				parts = append(parts, "last_role="+role)
-			}
-			if _, ok := last["tool_call_id"].(string); ok {
-				parts = append(parts, "last_has_tool_call_id=true")
-			}
-		}
-	}
-	if tools, ok := req["tools"].([]map[string]any); ok {
-		names := make([]string, 0, len(tools))
-		for _, tool := range tools {
-			fn, _ := tool["function"].(map[string]any)
-			name, _ := fn["name"].(string)
-			if name != "" {
-				names = append(names, name)
-			}
-		}
-		parts = append(parts, fmt.Sprintf("tools=%d", len(tools)))
-		if len(names) > 0 {
-			parts = append(parts, "tool_names="+strings.Join(names, ","))
-		}
-	}
-	if len(parts) == 0 {
-		return "request_context=unavailable"
-	}
-	return strings.Join(parts, " ")
-}
-
 const defaultImageModel = "openai/gpt-image-2/text-to-image"
 
 // GenerateImage creates an image using Atlas Cloud's async image API.

ai/atlascloud/atlascloud_test.go

@@ -2,12 +2,7 @@ package atlascloud
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -86,651 +81,16 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }
 
-func TestProvider_Stream(t *testing.T) {
-	var sawStream, sawIncludeUsage bool
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Errorf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		sawStream, _ = body["stream"].(bool)
-		if so, ok := body["stream_options"].(map[string]any); ok {
-			sawIncludeUsage, _ = so["include_usage"].(bool)
-		}
-		w.Header().Set("Content-Type", "text/event-stream")
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[],\"usage\":{\"prompt_tokens\":7,\"completion_tokens\":2,\"total_tokens\":9}}\n\n"))
-		_, _ = w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer ts.Close()
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	p := NewProvider()
 
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-	if err != nil {
-		t.Fatalf("Stream returned error: %v", err)
-	}
-	defer stream.Close()
-	if !sawStream {
-		t.Fatal("stream request did not set stream=true")
-	}
-	if !sawIncludeUsage {
-		t.Fatal("stream request did not set stream_options.include_usage=true")
+	req := &ai.Request{
+		Prompt: "Hello",
 	}
 
-	first, err := stream.Recv()
-	if err != nil || first.Reply != "hel" {
-		t.Fatalf("first chunk = %#v, %v; want hel", first, err)
-	}
-	second, err := stream.Recv()
-	if err != nil || second.Reply != "lo" {
-		t.Fatalf("second chunk = %#v, %v; want lo", second, err)
-	}
-	usage, err := stream.Recv()
-	if err != nil {
-		t.Fatalf("usage chunk error: %v", err)
-	}
-	if usage.Usage.TotalTokens != 9 || usage.Usage.InputTokens != 7 || usage.Usage.OutputTokens != 2 {
-		t.Fatalf("usage = %#v; want input=7 output=2 total=9", usage.Usage)
-	}
-	if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-		t.Fatalf("final error = %v, want EOF", err)
-	}
-}
-
-func TestProvider_StreamWithToolsFallsBack(t *testing.T) {
-	p := NewProvider(ai.WithAPIKey("test-key"))
-	_, err := p.Stream(context.Background(), &ai.Request{
-		Prompt: "call a tool",
-		Tools: []ai.Tool{{
-			Name:        "fallback_echo",
-			Description: "echo fallback marker",
-			Properties:  map[string]any{"value": map[string]any{"type": "string"}},
-		}},
-	})
+	_, err := p.Stream(context.Background(), req)
 	if !errors.Is(err, ai.ErrStreamingUnsupported) {
-		t.Fatalf("Stream with tools error = %v, want ErrStreamingUnsupported", err)
-	}
-}
-
-func TestProvider_GenerateToolCallEmptyFollowUpUsesToolResult(t *testing.T) {
-	var calls int
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Errorf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		calls++
-		w.Header().Set("Content-Type", "application/json")
-		switch calls {
-		case 1:
-			_, _ = 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":""}}]}`))
-		default:
-			t.Fatalf("unexpected API call %d", calls)
-		}
-	}))
-	defer ts.Close()
-
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			if call.Name != "conformance_echo" {
-				t.Fatalf("tool name = %q, want conformance_echo", call.Name)
-			}
-			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 conformance marker",
-			Properties:  map[string]any{"value": map[string]any{"type": "string"}},
-		}},
-	})
-	if err != nil {
-		t.Fatalf("Generate returned error: %v", err)
-	}
-	if calls != 2 {
-		t.Fatalf("API calls = %d, want 2", calls)
-	}
-	if resp.Answer != `{"marker":"agent-conformance-ok"}` {
-		t.Fatalf("Answer = %q, want tool result fallback", resp.Answer)
-	}
-}
-
-func TestProvider_GenerateMinimaxToolRequests(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:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"done"}}]}`))
-		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"),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		SystemPrompt: "You are helpful.",
-		Prompt:       "call a tool",
-		Tools: []ai.Tool{{
-			Name:        "conformance_echo",
-			Description: "echo conformance marker",
-			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 len(bodies) != 2 {
-		t.Fatalf("captured requests = %d, want 2", len(bodies))
-	}
-	if got := bodies[0]["model"]; got != "minimaxai/minimax-m3" {
-		t.Fatalf("initial model = %v", got)
-	}
-	tools, ok := bodies[0]["tools"].([]any)
-	if !ok || len(tools) != 1 {
-		t.Fatalf("initial tools = %#v, want one tool", bodies[0]["tools"])
-	}
-	tool := tools[0].(map[string]any)
-	if tool["type"] != "function" {
-		t.Fatalf("tool type = %v, want function", tool["type"])
-	}
-	fn := tool["function"].(map[string]any)
-	if fn["name"] != "conformance_echo" {
-		t.Fatalf("tool function name = %v", fn["name"])
-	}
-	params := fn["parameters"].(map[string]any)
-	if params["type"] != "object" {
-		t.Fatalf("parameters type = %v, want object", params["type"])
-	}
-
-	followUpMessages := bodies[1]["messages"].([]any)
-	if len(followUpMessages) != 4 {
-		t.Fatalf("follow-up messages = %d, want 4", len(followUpMessages))
-	}
-	assistant := followUpMessages[2].(map[string]any)
-	if assistant["role"] != "assistant" {
-		t.Fatalf("assistant role = %v", assistant["role"])
-	}
-	assistantCalls := assistant["tool_calls"].([]any)
-	assistantCall := assistantCalls[0].(map[string]any)
-	if assistantCall["type"] != "function" {
-		t.Fatalf("assistant tool call type = %v, want function", assistantCall["type"])
-	}
-	toolResult := followUpMessages[3].(map[string]any)
-	if toolResult["role"] != "tool" || toolResult["tool_call_id"] != "call-1" {
-		t.Fatalf("tool result message = %#v", toolResult)
-	}
-}
-
-func TestProvider_GenerateNormalizesBuiltInToolSchemas(t *testing.T) {
-	var body map[string]any
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		w.Header().Set("Content-Type", "application/json")
-		_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"ok"}}]}`))
-	}))
-	defer ts.Close()
-
-	planProperties := map[string]any{
-		"steps": map[string]any{
-			"type":        "array",
-			"description": "ordered plan steps",
-		},
-	}
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithModel("minimaxai/minimax-m3"),
-	)
-	_, 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: planProperties},
-			{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)
-	}
-
-	tools := body["tools"].([]any)
-	if len(tools) != 4 {
-		t.Fatalf("tools = %d, want custom tool plus built-ins", len(tools))
-	}
-	planTool := tools[1].(map[string]any)
-	fn := planTool["function"].(map[string]any)
-	params := fn["parameters"].(map[string]any)
-	props := params["properties"].(map[string]any)
-	steps := props["steps"].(map[string]any)
-	if _, ok := steps["items"].(map[string]any); !ok {
-		t.Fatalf("plan steps schema = %#v, want array items for AtlasCloud/minimax", steps)
-	}
-	if _, mutated := planProperties["steps"].(map[string]any)["items"]; mutated {
-		t.Fatalf("Generate mutated caller tool schema: %#v", planProperties)
-	}
-}
-
-func TestProvider_GenerateExecutesFollowUpToolCall(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:
-			_, _ = 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))
-		}
-	}))
-	defer ts.Close()
-
-	var sawEcho, sawDelegate bool
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			switch call.Name {
-			case "conformance_echo":
-				sawEcho = true
-				return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
-			case "delegate":
-				sawDelegate = true
-				return ai.ToolResult{ID: call.ID, Refused: ai.RefusedApproval, Content: "blocked by policy"}
-			default:
-				t.Fatalf("unexpected tool call %+v", call)
-				return ai.ToolResult{}
-			}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "run conformance",
-		Tools: []ai.Tool{
-			{Name: "conformance_echo", Description: "echo conformance marker", Properties: map[string]any{"value": 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 !sawEcho || !sawDelegate {
-		t.Fatalf("sawEcho=%v sawDelegate=%v, want both tools executed", sawEcho, sawDelegate)
-	}
-	if len(resp.ToolCalls) != 2 {
-		t.Fatalf("ToolCalls = %+v, want echo and delegate", resp.ToolCalls)
-	}
-	if resp.ToolCalls[1].Name != "delegate" || resp.ToolCalls[1].Error != ai.RefusedApproval {
-		t.Fatalf("follow-up delegate = %+v, want refused delegate", resp.ToolCalls[1])
-	}
-	if !strings.Contains(resp.Answer, "blocked by policy") {
-		t.Fatalf("Answer = %q, want follow-up tool result", resp.Answer)
-	}
-	if _, ok := bodies[1]["tools"].([]any); !ok {
-		t.Fatalf("follow-up request did not include tools: %#v", bodies[1])
-	}
-}
-
-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) {
-		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:
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"<tool_call name=\"delegate\">{\"task\":\"summarize the conformance marker\",\"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.WithToolHandler(func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-			if call.Name != "conformance_echo" {
-				t.Fatalf("unexpected structured tool call %+v", call)
-			}
-			return ai.ToolResult{ID: call.ID, Content: `{"marker":"agent-conformance-ok"}`}
-		}),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "run conformance",
-		Tools: []ai.Tool{
-			{Name: "conformance_echo", Description: "echo conformance marker", Properties: map[string]any{"value": 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 tagged delegate follow-up for agent text fallback", resp.Reply)
-	}
-	if resp.Answer != "" {
-		t.Fatalf("Answer = %q, want follow-up text preserved only as Reply", resp.Answer)
-	}
-}
-
-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_GenerateRetriesMinimaxServiceToolsAsTextTools(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:
-			if _, ok := body["tools"]; ok {
-				t.Fatalf("text-tool retry included native tools: %#v", body["tools"])
-			}
-			_, _ = w.Write([]byte(`{"choices":[{"message":{"content":"<tool_call name=\"conformance_echo\">{\"value\":\"agent-conformance\"}</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: "call a tool",
-		Tools: []ai.Tool{{
-			Name:        "conformance_echo",
-			Description: "echo conformance marker",
-			Properties:  map[string]any{"value": map[string]any{"type": "string"}},
-		}},
-	})
-	if err != nil {
-		t.Fatalf("Generate returned error: %v", err)
-	}
-	if !strings.Contains(resp.Reply, `<tool_call name="conformance_echo">`) {
-		t.Fatalf("Reply = %q, want text service-tool fallback", resp.Reply)
-	}
-	if len(bodies) != 2 {
-		t.Fatalf("requests = %d, want initial plus text-tool retry", len(bodies))
-	}
-	if _, ok := bodies[0]["tools"].([]any); !ok {
-		t.Fatalf("initial request did not include native tools: %#v", bodies[0])
-	}
-	msgs := bodies[1]["messages"].([]any)
-	compat := msgs[len(msgs)-1].(map[string]any)
-	content := compat["content"].(string)
-	for _, want := range []string{"native tools payload was rejected", `<tool_call name="tool_name">`, "conformance_echo"} {
-		if !strings.Contains(content, want) {
-			t.Fatalf("text-tool instruction %q missing %q", content, want)
-		}
-	}
-}
-
-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"])
-			}
-			messages := body["messages"].([]any)
-			last := messages[len(messages)-1].(map[string]any)
-			if last["role"] == "tool" {
-				http.Error(w, `{"code":400,"msg":"trailing tool message rejected"}`, http.StatusBadRequest)
-				return
-			}
-			if last["role"] != "user" || !strings.Contains(last["content"].(string), "Tool result for call-1") {
-				t.Fatalf("no-tools retry last message = %#v, want user-visible tool result", last)
-			}
-			assistant := messages[len(messages)-2].(map[string]any)
-			if _, ok := assistant["tool_calls"]; ok {
-				t.Fatalf("no-tools retry assistant still included tool_calls: %#v", assistant)
-			}
-			_, _ = 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)
-	}))
-	defer ts.Close()
-
-	p := NewProvider(
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL(ts.URL),
-		ai.WithModel("deepseek-ai/DeepSeek-V3-0324"),
-	)
-	_, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "call a tool",
-		Tools: []ai.Tool{{
-			Name:        "conformance_echo",
-			Description: "echo conformance marker",
-			Properties:  map[string]any{"value": map[string]any{"type": "string"}},
-		}},
-	})
-	if err == nil {
-		t.Fatal("Generate error = nil, want 400")
-	}
-	msg := err.Error()
-	for _, want := range []string{"400 Bad Request", "atlascloud chat request", "model=deepseek-ai/DeepSeek-V3-0324", "tools=1", "tool_names=conformance_echo"} {
-		if !strings.Contains(msg, want) {
-			t.Fatalf("error %q missing %q", msg, want)
-		}
-	}
-	if strings.Contains(msg, "test-key") {
-		t.Fatalf("error leaked API key: %s", msg)
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }
 

ai/capabilities_test.go

@@ -9,7 +9,6 @@ import (
 	_ "go-micro.dev/v6/ai/atlascloud"
 	_ "go-micro.dev/v6/ai/gemini"
 	_ "go-micro.dev/v6/ai/groq"
-	_ "go-micro.dev/v6/ai/minimax"
 	_ "go-micro.dev/v6/ai/mistral"
 	_ "go-micro.dev/v6/ai/openai"
 	_ "go-micro.dev/v6/ai/together"
@@ -17,7 +16,7 @@ import (
 
 func TestRegisteredProviders(t *testing.T) {
 	got := ai.RegisteredProviders("")
-	want := []string{"anthropic", "atlascloud", "gemini", "groq", "minimax", "mistral", "openai", "together"}
+	want := []string{"anthropic", "atlascloud", "gemini", "groq", "mistral", "openai", "together"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders() = %#v, want %#v", got, want)
 	}
@@ -35,7 +34,7 @@ func TestRegisteredProviders(t *testing.T) {
 	}
 
 	got = ai.RegisteredProviders("stream")
-	want = []string{"anthropic", "atlascloud", "groq", "minimax", "mistral", "openai", "together"}
+	want = []string{"openai"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
 	}
@@ -44,14 +43,13 @@ func TestRegisteredProviders(t *testing.T) {
 func TestCapabilityRows(t *testing.T) {
 	got := ai.CapabilityRows()
 	want := []ai.CapabilityRow{
-		{Provider: "anthropic", Capabilities: ai.Capabilities{Model: true, Stream: true}},
-		{Provider: "atlascloud", Capabilities: ai.Capabilities{Model: true, Image: true, Video: true, Stream: true}},
+		{Provider: "anthropic", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "atlascloud", Capabilities: ai.Capabilities{Model: true, Image: true, Video: true}},
 		{Provider: "gemini", Capabilities: ai.Capabilities{Model: true}},
-		{Provider: "groq", Capabilities: ai.Capabilities{Model: true, Stream: true}},
-		{Provider: "minimax", Capabilities: ai.Capabilities{Model: true, Stream: true}},
-		{Provider: "mistral", Capabilities: ai.Capabilities{Model: true, Stream: true}},
+		{Provider: "groq", Capabilities: ai.Capabilities{Model: true}},
+		{Provider: "mistral", Capabilities: ai.Capabilities{Model: true}},
 		{Provider: "openai", Capabilities: ai.Capabilities{Model: true, Image: true, Stream: true}},
-		{Provider: "together", Capabilities: ai.Capabilities{Model: true, Stream: true}},
+		{Provider: "together", Capabilities: ai.Capabilities{Model: true}},
 	}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("CapabilityRows() = %#v, want %#v", got, want)
@@ -61,7 +59,7 @@ func TestCapabilityRows(t *testing.T) {
 func TestCapabilityMatrix(t *testing.T) {
 	matrix := ai.CapabilityMatrix()
 
-	for _, provider := range []string{"anthropic", "atlascloud", "gemini", "groq", "minimax", "mistral", "openai", "together"} {
+	for _, provider := range []string{"anthropic", "atlascloud", "gemini", "groq", "mistral", "openai", "together"} {
 		caps, ok := matrix[provider]
 		if !ok {
 			t.Fatalf("CapabilityMatrix missing %q", provider)
@@ -74,7 +72,7 @@ func TestCapabilityMatrix(t *testing.T) {
 	if caps := ai.ProviderCapabilities("openai"); caps != (ai.Capabilities{Model: true, Image: true, Stream: true}) {
 		t.Fatalf("ProviderCapabilities(openai) = %#v", caps)
 	}
-	if caps := ai.ProviderCapabilities("atlascloud"); caps != (ai.Capabilities{Model: true, Image: true, Video: true, Stream: true}) {
+	if caps := ai.ProviderCapabilities("atlascloud"); caps != (ai.Capabilities{Model: true, Image: true, Video: true}) {
 		t.Fatalf("ProviderCapabilities(atlascloud) = %#v", caps)
 	}
 	if caps := ai.ProviderCapabilities("missing"); caps != (ai.Capabilities{}) {
@@ -90,7 +88,7 @@ func TestRegisterStream(t *testing.T) {
 	}
 
 	got := ai.RegisteredProviders("stream")
-	want := []string{"anthropic", "atlascloud", "groq", "minimax", "mistral", "openai", "test-stream", "together"}
+	want := []string{"openai", "test-stream"}
 	if !reflect.DeepEqual(got, want) {
 		t.Fatalf("RegisteredProviders(stream) = %#v, want %#v", got, want)
 	}

ai/gemini/gemini.go

@@ -163,7 +163,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var geminiResp struct {

ai/groq/groq.go

@@ -22,14 +22,12 @@ import (
 	"strings"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/ai/internal/openaiapi"
 )
 
 func init() {
 	ai.Register("groq", func(opts ...ai.Option) ai.Model {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("groq")
 }
 
 type Provider struct {
@@ -121,7 +119,7 @@ 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) {
-	return openaiapi.Stream(ctx, p.opts, req, "/v1/chat/completions")
+	return nil, fmt.Errorf("%w: groq provider", ai.ErrStreamingUnsupported)
 }
 
 func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {
@@ -147,7 +145,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/groq/groq_test.go

@@ -2,11 +2,7 @@ package groq
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -44,44 +40,9 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }
 
-func TestProvider_Stream(t *testing.T) {
-	var sawStream bool
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Fatalf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		sawStream, _ = body["stream"].(bool)
-		w.Header().Set("Content-Type", "text/event-stream")
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-	if err != nil {
-		t.Fatalf("Stream returned error: %v", err)
-	}
-	defer stream.Close()
-	if !sawStream {
-		t.Fatal("stream request did not set stream=true")
-	}
-
-	first, err := stream.Recv()
-	if err != nil || first.Reply != "hel" {
-		t.Fatalf("first chunk = %#v, %v; want hel", first, err)
-	}
-	second, err := stream.Recv()
-	if err != nil || second.Reply != "lo" {
-		t.Fatalf("second chunk = %#v, %v; want lo", second, err)
-	}
-	if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-		t.Fatalf("final error = %v, want EOF", err)
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	if _, err := NewProvider().Stream(context.Background(), &ai.Request{Prompt: "hi"}); !errors.Is(err, ai.ErrStreamingUnsupported) {
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }
 

ai/internal/openaiapi/stream.go

@@ -1,117 +0,0 @@
-package openaiapi
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"go-micro.dev/v6/ai"
-)
-
-// Stream opens an OpenAI-compatible chat completions SSE stream.
-func Stream(ctx context.Context, opts ai.Options, req *ai.Request, basePath string) (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":          opts.Model,
-		"messages":       messages,
-		"stream":         true,
-		"stream_options": map[string]any{"include_usage": true},
-	}
-	if opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = opts.MaxTokens
-	}
-	reqBody, err := json.Marshal(apiReq)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal stream request: %w", err)
-	}
-	apiURL := strings.TrimRight(opts.BaseURL, "/") + basePath
-	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 "+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 &StreamReader{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-// StreamReader reads OpenAI-compatible server-sent event chunks.
-type StreamReader struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *StreamReader) 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
-		}
-		if chunk.Usage != nil {
-			return &ai.Response{Usage: ai.Usage{
-				InputTokens:  chunk.Usage.PromptTokens,
-				OutputTokens: chunk.Usage.CompletionTokens,
-				TotalTokens:  chunk.Usage.TotalTokens,
-			}}, nil
-		}
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *StreamReader) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
-}

ai/minimax/minimax.go

@@ -1,196 +0,0 @@
-// Package minimax implements the MiniMax model provider.
-//
-// MiniMax offers its flagship MiniMax-M3 model via an OpenAI-compatible
-// chat completions endpoint.
-//
-// Usage:
-//
-//	import _ "go-micro.dev/v6/ai/minimax"
-//
-//	m := ai.New("minimax",
-//	    ai.WithAPIKey("your-api-key"),
-//	)
-package minimax
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/ai/internal/openaiapi"
-)
-
-func init() {
-	ai.Register("minimax", func(opts ...ai.Option) ai.Model {
-		return NewProvider(opts...)
-	})
-	ai.RegisterStream("minimax")
-}
-
-type Provider struct {
-	opts ai.Options
-}
-
-func NewProvider(opts ...ai.Option) *Provider {
-	options := ai.NewOptions(opts...)
-	if options.Model == "" {
-		options.Model = "MiniMax-M3"
-	}
-	if options.BaseURL == "" {
-		options.BaseURL = "https://api.minimax.io"
-	}
-	return &Provider{opts: options}
-}
-
-func (p *Provider) Init(opts ...ai.Option) error {
-	for _, o := range opts {
-		o(&p.opts)
-	}
-	return nil
-}
-
-func (p *Provider) Options() ai.Options { return p.opts }
-func (p *Provider) String() string      { return "minimax" }
-
-func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (*ai.Response, error) {
-	var tools []map[string]any
-	for _, t := range req.Tools {
-		tools = append(tools, map[string]any{
-			"type": "function",
-			"function": map[string]any{
-				"name":        t.Name,
-				"description": t.Description,
-				"parameters": map[string]any{
-					"type":       "object",
-					"properties": t.Properties,
-				},
-			},
-		})
-	}
-
-	messages := []map[string]any{
-		{"role": "system", "content": req.SystemPrompt},
-		{"role": "user", "content": req.Prompt},
-	}
-
-	apiReq := map[string]any{
-		"model":    p.opts.Model,
-		"messages": messages,
-	}
-	if len(tools) > 0 {
-		apiReq["tools"] = tools
-	}
-
-	resp, rawMessage, err := p.callAPI(ctx, apiReq)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp.ToolCalls) == 0 {
-		return resp, nil
-	}
-
-	if p.opts.ToolHandler != nil {
-		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
-			followUpMessages = append(followUpMessages, map[string]any{
-				"role":         "tool",
-				"tool_call_id": tc.ID,
-				"content":      content,
-			})
-		}
-		followUpResp, _, err := p.callAPI(ctx, map[string]any{
-			"model":    p.opts.Model,
-			"messages": followUpMessages,
-		})
-		if err == nil && followUpResp.Reply != "" {
-			resp.Answer = followUpResp.Reply
-		}
-	}
-
-	return resp, nil
-}
-
-func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	return openaiapi.Stream(ctx, p.opts, req, "/v1/chat/completions")
-}
-
-func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {
-	reqBody, err := json.Marshal(req)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal 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, nil, fmt.Errorf("failed to create request: %w", err)
-	}
-
-	httpReq.Header.Set("Content-Type", "application/json")
-	httpReq.Header.Set("Authorization", "Bearer "+p.opts.APIKey)
-
-	httpResp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, nil, fmt.Errorf("API request failed: %w", err)
-	}
-	defer httpResp.Body.Close()
-
-	respBody, _ := io.ReadAll(httpResp.Body)
-	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
-	}
-
-	var chatResp struct {
-		Choices []struct {
-			Message struct {
-				Content   string `json:"content"`
-				ToolCalls []struct {
-					ID       string `json:"id"`
-					Function struct {
-						Name      string `json:"name"`
-						Arguments string `json:"arguments"`
-					} `json:"function"`
-				} `json:"tool_calls"`
-			} `json:"message"`
-		} `json:"choices"`
-	}
-
-	if err := json.Unmarshal(respBody, &chatResp); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse response: %w", err)
-	}
-	if len(chatResp.Choices) == 0 {
-		return nil, nil, fmt.Errorf("no response from API")
-	}
-
-	choice := chatResp.Choices[0]
-	response := &ai.Response{Reply: choice.Message.Content}
-
-	for _, tc := range choice.Message.ToolCalls {
-		var input map[string]any
-		if err := json.Unmarshal([]byte(tc.Function.Arguments), &input); err != nil {
-			input = map[string]any{}
-		}
-		response.ToolCalls = append(response.ToolCalls, ai.ToolCall{
-			ID:    tc.ID,
-			Name:  tc.Function.Name,
-			Input: input,
-		})
-	}
-
-	rawMessage := map[string]any{
-		"content":    choice.Message.Content,
-		"tool_calls": choice.Message.ToolCalls,
-	}
-
-	return response, rawMessage, nil
-}

ai/minimax/minimax_test.go

@@ -1,96 +0,0 @@
-package minimax
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-)
-
-func TestProvider_String(t *testing.T) {
-	if NewProvider().String() != "minimax" {
-		t.Errorf("got %q", NewProvider().String())
-	}
-}
-
-func TestProvider_Defaults(t *testing.T) {
-	opts := NewProvider().Options()
-	if opts.Model != "MiniMax-M3" {
-		t.Errorf("default model = %q", opts.Model)
-	}
-	if opts.BaseURL != "https://api.minimax.io" {
-		t.Errorf("default base URL = %q", opts.BaseURL)
-	}
-}
-
-func TestProvider_Init(t *testing.T) {
-	p := NewProvider()
-	if err := p.Init(ai.WithModel("m"), ai.WithAPIKey("k")); err != nil {
-		t.Fatal(err)
-	}
-	if p.Options().Model != "m" || p.Options().APIKey != "k" {
-		t.Error("Init did not apply options")
-	}
-}
-
-func TestProvider_Generate_NoAPIKey(t *testing.T) {
-	if _, err := NewProvider().Generate(context.Background(), &ai.Request{Prompt: "hi"}); err == nil {
-		t.Error("expected error without API key")
-	}
-}
-
-func TestProvider_Stream(t *testing.T) {
-	var sawStream bool
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Fatalf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		sawStream, _ = body["stream"].(bool)
-		w.Header().Set("Content-Type", "text/event-stream")
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-	if err != nil {
-		t.Fatalf("Stream returned error: %v", err)
-	}
-	defer stream.Close()
-	if !sawStream {
-		t.Fatal("stream request did not set stream=true")
-	}
-
-	first, err := stream.Recv()
-	if err != nil || first.Reply != "hel" {
-		t.Fatalf("first chunk = %#v, %v; want hel", first, err)
-	}
-	second, err := stream.Recv()
-	if err != nil || second.Reply != "lo" {
-		t.Fatalf("second chunk = %#v, %v; want lo", second, err)
-	}
-	if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-		t.Fatalf("final error = %v, want EOF", err)
-	}
-}
-
-func TestProvider_Registration(t *testing.T) {
-	m := ai.New("minimax", ai.WithAPIKey("test"))
-	if m == nil {
-		t.Fatal("provider not registered")
-	}
-	if m.String() != "minimax" {
-		t.Errorf("got %q", m.String())
-	}
-}

ai/mistral/mistral.go

@@ -22,14 +22,12 @@ import (
 	"strings"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/ai/internal/openaiapi"
 )
 
 func init() {
 	ai.Register("mistral", func(opts ...ai.Option) ai.Model {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("mistral")
 }
 
 type Provider struct {
@@ -121,7 +119,7 @@ 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) {
-	return openaiapi.Stream(ctx, p.opts, req, "/v1/chat/completions")
+	return nil, fmt.Errorf("%w: mistral provider", ai.ErrStreamingUnsupported)
 }
 
 func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {
@@ -147,7 +145,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/mistral/mistral_test.go

@@ -2,11 +2,7 @@ package mistral
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -44,44 +40,9 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }
 
-func TestProvider_Stream(t *testing.T) {
-	var sawStream bool
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Fatalf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		sawStream, _ = body["stream"].(bool)
-		w.Header().Set("Content-Type", "text/event-stream")
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-	if err != nil {
-		t.Fatalf("Stream returned error: %v", err)
-	}
-	defer stream.Close()
-	if !sawStream {
-		t.Fatal("stream request did not set stream=true")
-	}
-
-	first, err := stream.Recv()
-	if err != nil || first.Reply != "hel" {
-		t.Fatalf("first chunk = %#v, %v; want hel", first, err)
-	}
-	second, err := stream.Recv()
-	if err != nil || second.Reply != "lo" {
-		t.Fatalf("second chunk = %#v, %v; want lo", second, err)
-	}
-	if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-		t.Fatalf("final error = %v, want EOF", err)
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	if _, err := NewProvider().Stream(context.Background(), &ai.Request{Prompt: "hi"}); !errors.Is(err, ai.ErrStreamingUnsupported) {
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }
 

ai/model.go

@@ -93,10 +93,9 @@ func (c ToolCall) Scan(v any) error {
 
 // ToolResult represents the result of a tool execution
 type ToolResult struct {
-	ID       string // Tool call ID (for correlation)
-	Value    any    // Structured result (optional)
-	Content  string // Tool execution result (JSON string), shown to the model
-	Attempts int    `json:"attempts,omitempty"` // Tool execution attempts, set when retried.
+	ID      string // Tool call ID (for correlation)
+	Value   any    // Structured result (optional)
+	Content string // Tool execution result (JSON string), shown to the model
 	// Refused names the reason a guardrail blocked the call before it ran
 	// ("max_steps", "loop", "approval"); empty when the call executed. A
 	// tool wrapper can switch on it to build reliability tooling — react to
@@ -122,16 +121,13 @@ const (
 // tell which provider attempt produced the call and whether it is part of a
 // retry budget. They are zero when no model-attempt context is known.
 type RunInfo struct {
-	RunID                string // correlation id for this agent or flow run
-	ParentID             string // the run that delegated to this one, if any
-	Agent                string // the agent's name
-	Flow                 string // the flow's name, when the call is part of a workflow
-	Step                 string // the flow step currently executing, when known
-	Attempt              int    // current model Generate attempt, starting at 1 when known
-	MaxAttempts          int    // configured model Generate attempt budget when known
-	VerificationFeedback string // feedback from the previous failed verifier attempt, when retrying a flow step
-	Dispatch             string // how the run was dispatched (direct, broker, schedule, resume) when known
-	Trigger              string // external trigger or schedule label that started the run, when known
+	RunID       string // correlation id for this agent or flow run
+	ParentID    string // the run that delegated to this one, if any
+	Agent       string // the agent's name
+	Flow        string // the flow's name, when the call is part of a workflow
+	Step        string // the flow step currently executing, when known
+	Attempt     int    // current model Generate attempt, starting at 1 when known
+	MaxAttempts int    // configured model Generate attempt budget when known
 }
 
 type runInfoKey struct{}
@@ -212,8 +208,6 @@ func AutoDetectProvider(baseURL string) string {
 		return "gemini"
 	case strings.Contains(baseURL, "groq"):
 		return "groq"
-	case strings.Contains(baseURL, "minimax"):
-		return "minimax"
 	case strings.Contains(baseURL, "mistral"):
 		return "mistral"
 	case strings.Contains(baseURL, "together"):

ai/ollama/ollama.go

@@ -1,729 +0,0 @@
-// Package ollama implements the Ollama model provider.
-//
-// Ollama runs open-weight models locally (or via Ollama Cloud). This
-// provider supports two API styles:
-//
-//   - Native (/api/chat):   local Ollama servers (default, http://localhost:11434)
-//   - OpenAI-compatible (/v1/chat/completions): Ollama Cloud (https://ollama.com/v1)
-//
-// The provider auto-detects which style to use based on the base URL.
-// Set OLLAMA_BASE_URL to point at your server (local or cloud).
-//
-// Usage (local):
-//
-//	import _ "go-micro.dev/v6/ai/ollama"
-//
-//	m := ai.New("ollama",
-//	    ai.WithBaseURL("http://localhost:11434"),
-//	    ai.WithModel("llama3.2"),
-//	)
-//
-// Usage (Ollama Cloud):
-//
-//	m := ai.New("ollama",
-//	    ai.WithBaseURL("https://ollama.com/v1"),
-//	    ai.WithAPIKey("your-key"),
-//	    ai.WithModel("gpt-oss:120b"),
-//	)
-package ollama
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"go-micro.dev/v6/ai"
-)
-
-func init() {
-	ai.Register("ollama", func(opts ...ai.Option) ai.Model {
-		return NewProvider(opts...)
-	})
-	ai.RegisterStream("ollama")
-}
-
-// Provider implements the ai.Model interface for Ollama.
-type Provider struct {
-	opts ai.Options
-
-	// cloudOverride forces cloud mode for testing. When true, the provider
-	// uses the OpenAI-compatible endpoint regardless of the base URL.
-	cloudOverride bool
-}
-
-// NewProvider creates a new Ollama provider.
-func NewProvider(opts ...ai.Option) *Provider {
-	options := ai.NewOptions(opts...)
-	if options.Model == "" {
-		options.Model = "llama3.2"
-	}
-	if options.BaseURL == "" {
-		options.BaseURL = "http://localhost:11434"
-	}
-	return &Provider{opts: options}
-}
-
-// Init initializes the provider with options.
-func (p *Provider) Init(opts ...ai.Option) error {
-	for _, o := range opts {
-		o(&p.opts)
-	}
-	return nil
-}
-
-// Options returns the provider options.
-func (p *Provider) Options() ai.Options { return p.opts }
-
-// String returns the provider name.
-func (p *Provider) String() string { return "ollama" }
-
-// isCloud returns true when the base URL points at Ollama Cloud (ollama.com),
-// which uses the OpenAI-compatible /v1/chat/completions endpoint instead of
-// the native /api/chat.
-func (p *Provider) isCloud() bool {
-	if p.cloudOverride {
-		return true
-	}
-	return strings.Contains(p.opts.BaseURL, "ollama.com")
-}
-
-// chatPath returns the API endpoint path for chat completions.
-func (p *Provider) chatPath() string {
-	if p.isCloud() {
-		return "/v1/chat/completions"
-	}
-	return "/api/chat"
-}
-
-// streamPath returns the API endpoint path for streaming chat.
-// Ollama Cloud uses the same /v1/chat/completions with stream:true.
-// Local Ollama uses /api/chat with stream:true.
-func (p *Provider) streamPath() string {
-	return p.chatPath()
-}
-
-// Generate generates a response from the Ollama model.
-func (p *Provider) Generate(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (*ai.Response, error) {
-	if p.isCloud() {
-		return p.generateOpenAI(ctx, req)
-	}
-	return p.generateNative(ctx, req)
-}
-
-// Stream generates a streaming response.
-func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.GenerateOption) (ai.Stream, error) {
-	if p.isCloud() {
-		return p.streamOpenAI(ctx, req)
-	}
-	return p.streamNative(ctx, req)
-}
-
-// ---------------------------------------------------------------------------
-// OpenAI-compatible mode (Ollama Cloud: ollama.com/v1)
-// ---------------------------------------------------------------------------
-
-func (p *Provider) generateOpenAI(ctx context.Context, req *ai.Request) (*ai.Response, error) {
-	var tools []map[string]any
-	for _, t := range req.Tools {
-		tools = append(tools, map[string]any{
-			"type": "function",
-			"function": map[string]any{
-				"name":        t.Name,
-				"description": t.Description,
-				"parameters": map[string]any{
-					"type":       "object",
-					"properties": t.Properties,
-				},
-			},
-		})
-	}
-
-	messages := buildOpenAIMessages(req)
-	apiReq := map[string]any{
-		"model":    p.opts.Model,
-		"messages": messages,
-		"stream":   false,
-	}
-	if len(tools) > 0 {
-		apiReq["tools"] = tools
-	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["max_tokens"] = p.opts.MaxTokens
-	}
-
-	resp, rawMsg, err := p.callOpenAI(ctx, apiReq)
-	if err != nil {
-		return nil, err
-	}
-
-	// No tool calls or no handler — return as-is.
-	if len(resp.ToolCalls) == 0 || p.opts.ToolHandler == nil {
-		return resp, nil
-	}
-
-	// Tool execution loop.
-	convMessages := append(messages, map[string]any{
-		"role":       "assistant",
-		"content":    rawMsg.content,
-		"tool_calls": rawMsg.toolCalls,
-	})
-
-	pendingCalls := resp.ToolCalls
-	for round := 0; round < 10; round++ {
-		for i := range pendingCalls {
-			result := p.opts.ToolHandler(ctx, pendingCalls[i])
-			pendingCalls[i].Result = result.Content
-			convMessages = append(convMessages, map[string]any{
-				"role":         "tool",
-				"tool_call_id": pendingCalls[i].ID,
-				"content":      result.Content,
-			})
-		}
-
-		followUpReq := map[string]any{
-			"model":    p.opts.Model,
-			"messages": convMessages,
-			"stream":   false,
-		}
-		if len(tools) > 0 {
-			followUpReq["tools"] = tools
-		}
-		if p.opts.MaxTokens > 0 {
-			followUpReq["max_tokens"] = p.opts.MaxTokens
-		}
-
-		followUpResp, followUpRaw, err := p.callOpenAI(ctx, followUpReq)
-		if err != nil {
-			break
-		}
-
-		if len(followUpResp.ToolCalls) > 0 {
-			resp.ToolCalls = append(resp.ToolCalls, followUpResp.ToolCalls...)
-			pendingCalls = followUpResp.ToolCalls
-			convMessages = append(convMessages, map[string]any{
-				"role":       "assistant",
-				"content":    followUpRaw.content,
-				"tool_calls": followUpRaw.toolCalls,
-			})
-			continue
-		}
-
-		if followUpResp.Reply != "" {
-			resp.Answer = followUpResp.Reply
-		}
-		break
-	}
-
-	return resp, nil
-}
-
-func (p *Provider) callOpenAI(ctx context.Context, req map[string]any) (*ai.Response, *rawChatMessage, error) {
-	reqBody, err := json.Marshal(req)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal request: %w", err)
-	}
-
-	apiURL := strings.TrimRight(p.opts.BaseURL, "/") + p.chatPath()
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(reqBody))
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	if p.opts.APIKey != "" {
-		httpReq.Header.Set("Authorization", "Bearer "+p.opts.APIKey)
-	}
-
-	httpResp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, nil, fmt.Errorf("API request failed: %w", err)
-	}
-	defer httpResp.Body.Close()
-
-	respBody, _ := io.ReadAll(httpResp.Body)
-	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
-	}
-
-	var chatResp struct {
-		Usage struct {
-			PromptTokens     int `json:"prompt_tokens"`
-			CompletionTokens int `json:"completion_tokens"`
-			TotalTokens      int `json:"total_tokens"`
-		} `json:"usage"`
-		Choices []struct {
-			Message struct {
-				Role      string `json:"role"`
-				Content   string `json:"content"`
-				ToolCalls []struct {
-					ID       string `json:"id"`
-					Function struct {
-						Name      string `json:"name"`
-						Arguments string `json:"arguments"`
-					} `json:"function"`
-				} `json:"tool_calls"`
-			} `json:"message"`
-		} `json:"choices"`
-	}
-
-	if err := json.Unmarshal(respBody, &chatResp); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse response: %w", err)
-	}
-	if len(chatResp.Choices) == 0 {
-		return nil, nil, fmt.Errorf("no response from API")
-	}
-
-	choice := chatResp.Choices[0]
-	response := &ai.Response{
-		Reply: choice.Message.Content,
-		Usage: ai.Usage{
-			InputTokens:  chatResp.Usage.PromptTokens,
-			OutputTokens: chatResp.Usage.CompletionTokens,
-			TotalTokens:  chatResp.Usage.TotalTokens,
-		},
-	}
-
-	var rawToolCalls []map[string]any
-	for _, tc := range choice.Message.ToolCalls {
-		var input map[string]any
-		if err := json.Unmarshal([]byte(tc.Function.Arguments), &input); err != nil {
-			input = map[string]any{}
-		}
-		response.ToolCalls = append(response.ToolCalls, ai.ToolCall{
-			ID:    tc.ID,
-			Name:  tc.Function.Name,
-			Input: input,
-		})
-		rawToolCalls = append(rawToolCalls, map[string]any{
-			"id":   tc.ID,
-			"type": "function",
-			"function": map[string]any{
-				"name":      tc.Function.Name,
-				"arguments": tc.Function.Arguments,
-			},
-		})
-	}
-
-	raw := &rawChatMessage{
-		content:   choice.Message.Content,
-		toolCalls: rawToolCalls,
-	}
-	return response, raw, nil
-}
-
-func (p *Provider) streamOpenAI(ctx context.Context, req *ai.Request) (ai.Stream, error) {
-	messages := buildOpenAIMessages(req)
-	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, "/") + p.streamPath()
-	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")
-	if p.opts.APIKey != "" {
-		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 &sseStream{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-// buildOpenAIMessages converts an ai.Request into the OpenAI chat message format.
-func buildOpenAIMessages(req *ai.Request) []map[string]any {
-	messages := []map[string]any{}
-	if req.SystemPrompt != "" {
-		messages = append(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})
-	}
-	return messages
-}
-
-// sseStream reads OpenAI-style server-sent events (used by Ollama Cloud).
-type sseStream struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *sseStream) 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
-		}
-		if chunk.Usage != nil {
-			return &ai.Response{Usage: ai.Usage{
-				InputTokens:  chunk.Usage.PromptTokens,
-				OutputTokens: chunk.Usage.CompletionTokens,
-				TotalTokens:  chunk.Usage.TotalTokens,
-			}}, nil
-		}
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *sseStream) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
-}
-
-// ---------------------------------------------------------------------------
-// Native mode (local Ollama: localhost:11434/api/chat)
-// ---------------------------------------------------------------------------
-
-func (p *Provider) generateNative(ctx context.Context, req *ai.Request) (*ai.Response, error) {
-	var tools []map[string]any
-	for _, t := range req.Tools {
-		tools = append(tools, map[string]any{
-			"type": "function",
-			"function": map[string]any{
-				"name":        t.Name,
-				"description": t.Description,
-				"parameters": map[string]any{
-					"type":       "object",
-					"properties": t.Properties,
-				},
-			},
-		})
-	}
-
-	messages := []map[string]any{}
-	if req.SystemPrompt != "" {
-		messages = append(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":   false,
-	}
-	if len(tools) > 0 {
-		apiReq["tools"] = tools
-	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["options"] = map[string]any{"num_predict": p.opts.MaxTokens}
-	}
-
-	resp, rawMsg, err := p.callNative(ctx, apiReq)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(resp.ToolCalls) == 0 || p.opts.ToolHandler == nil {
-		return resp, nil
-	}
-
-	convMessages := append(messages, map[string]any{
-		"role":    "assistant",
-		"content": rawMsg.content,
-	})
-	if len(rawMsg.toolCalls) > 0 {
-		convMessages[len(convMessages)-1]["tool_calls"] = rawMsg.toolCalls
-	}
-
-	pendingCalls := resp.ToolCalls
-	for round := 0; round < 10; round++ {
-		for i := range pendingCalls {
-			result := p.opts.ToolHandler(ctx, pendingCalls[i])
-			pendingCalls[i].Result = result.Content
-			convMessages = append(convMessages, map[string]any{
-				"role":    "tool",
-				"content": result.Content,
-			})
-		}
-
-		followUpReq := map[string]any{
-			"model":    p.opts.Model,
-			"messages": convMessages,
-			"stream":   false,
-		}
-		if len(tools) > 0 {
-			followUpReq["tools"] = tools
-		}
-		if p.opts.MaxTokens > 0 {
-			followUpReq["options"] = map[string]any{"num_predict": p.opts.MaxTokens}
-		}
-
-		followUpResp, followUpRaw, err := p.callNative(ctx, followUpReq)
-		if err != nil {
-			break
-		}
-
-		if len(followUpResp.ToolCalls) > 0 {
-			resp.ToolCalls = append(resp.ToolCalls, followUpResp.ToolCalls...)
-			pendingCalls = followUpResp.ToolCalls
-			convMessages = append(convMessages, map[string]any{
-				"role":    "assistant",
-				"content": followUpRaw.content,
-			})
-			if len(followUpRaw.toolCalls) > 0 {
-				convMessages[len(convMessages)-1]["tool_calls"] = followUpRaw.toolCalls
-			}
-			continue
-		}
-
-		if followUpResp.Reply != "" {
-			resp.Answer = followUpResp.Reply
-		}
-		break
-	}
-
-	return resp, nil
-}
-
-func (p *Provider) callNative(ctx context.Context, req map[string]any) (*ai.Response, *rawChatMessage, error) {
-	reqBody, err := json.Marshal(req)
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to marshal request: %w", err)
-	}
-
-	apiURL := strings.TrimRight(p.opts.BaseURL, "/") + p.chatPath()
-	httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, apiURL, bytes.NewReader(reqBody))
-	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create request: %w", err)
-	}
-	httpReq.Header.Set("Content-Type", "application/json")
-	if p.opts.APIKey != "" {
-		httpReq.Header.Set("Authorization", "Bearer "+p.opts.APIKey)
-	}
-
-	httpResp, err := http.DefaultClient.Do(httpReq)
-	if err != nil {
-		return nil, nil, fmt.Errorf("API request failed: %w", err)
-	}
-	defer httpResp.Body.Close()
-
-	respBody, _ := io.ReadAll(httpResp.Body)
-	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
-	}
-
-	var chatResp struct {
-		Message struct {
-			Role      string `json:"role"`
-			Content   string `json:"content"`
-			ToolCalls []struct {
-				Function struct {
-					Name      string `json:"name"`
-					Arguments any    `json:"arguments"`
-				} `json:"function"`
-			} `json:"tool_calls"`
-		} `json:"message"`
-		Done            bool `json:"done"`
-		PromptEvalCount int  `json:"prompt_eval_count"`
-		EvalCount       int  `json:"eval_count"`
-	}
-
-	if err := json.Unmarshal(respBody, &chatResp); err != nil {
-		return nil, nil, fmt.Errorf("failed to parse response: %w", err)
-	}
-
-	response := &ai.Response{
-		Reply: chatResp.Message.Content,
-		Usage: ai.Usage{
-			InputTokens:  chatResp.PromptEvalCount,
-			OutputTokens: chatResp.EvalCount,
-			TotalTokens:  chatResp.PromptEvalCount + chatResp.EvalCount,
-		},
-	}
-
-	var rawToolCalls []map[string]any
-	for _, tc := range chatResp.Message.ToolCalls {
-		var input map[string]any
-		switch v := tc.Function.Arguments.(type) {
-		case string:
-			if err := json.Unmarshal([]byte(v), &input); err != nil {
-				input = map[string]any{}
-			}
-		case map[string]any:
-			input = v
-		default:
-			input = map[string]any{}
-		}
-		response.ToolCalls = append(response.ToolCalls, ai.ToolCall{
-			Name:  tc.Function.Name,
-			Input: input,
-		})
-		rawToolCalls = append(rawToolCalls, map[string]any{
-			"function": map[string]any{
-				"name":      tc.Function.Name,
-				"arguments": tc.Function.Arguments,
-			},
-		})
-	}
-
-	raw := &rawChatMessage{
-		content:   chatResp.Message.Content,
-		toolCalls: rawToolCalls,
-	}
-	return response, raw, nil
-}
-
-func (p *Provider) streamNative(ctx context.Context, req *ai.Request) (ai.Stream, error) {
-	messages := []map[string]any{}
-	if req.SystemPrompt != "" {
-		messages = append(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,
-	}
-	if p.opts.MaxTokens > 0 {
-		apiReq["options"] = map[string]any{"num_predict": 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, "/") + p.streamPath()
-	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")
-	if p.opts.APIKey != "" {
-		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 &ndjsonStream{body: httpResp.Body, scanner: bufio.NewScanner(httpResp.Body)}, nil
-}
-
-// ndjsonStream reads newline-delimited JSON (used by local Ollama).
-type ndjsonStream struct {
-	body    io.ReadCloser
-	scanner *bufio.Scanner
-	closed  bool
-}
-
-func (s *ndjsonStream) Recv() (*ai.Response, error) {
-	for s.scanner.Scan() {
-		line := strings.TrimSpace(s.scanner.Text())
-		if line == "" {
-			continue
-		}
-		var chunk struct {
-			Message struct {
-				Content string `json:"content"`
-			} `json:"message"`
-			Done bool `json:"done"`
-		}
-		if err := json.Unmarshal([]byte(line), &chunk); err != nil {
-			return nil, fmt.Errorf("failed to parse stream chunk: %w", err)
-		}
-		if chunk.Done {
-			return nil, io.EOF
-		}
-		if chunk.Message.Content != "" {
-			return &ai.Response{Reply: chunk.Message.Content}, nil
-		}
-	}
-	if err := s.scanner.Err(); err != nil {
-		return nil, err
-	}
-	return nil, io.EOF
-}
-
-func (s *ndjsonStream) Close() error {
-	if s.closed {
-		return nil
-	}
-	s.closed = true
-	return s.body.Close()
-}
-
-// rawChatMessage holds the raw assistant content and tool calls for
-// follow-up messages.
-type rawChatMessage struct {
-	content   string
-	toolCalls []map[string]any
-}

ai/ollama/ollama_test.go

@@ -1,333 +0,0 @@
-package ollama
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"go-micro.dev/v6/ai"
-)
-
-// ---------------------------------------------------------------------------
-// Provider basics
-// ---------------------------------------------------------------------------
-
-func TestProvider_String(t *testing.T) {
-	p := NewProvider()
-	if p.String() != "ollama" {
-		t.Errorf("Expected 'ollama', got '%s'", p.String())
-	}
-}
-
-func TestProvider_Init(t *testing.T) {
-	p := NewProvider()
-	err := p.Init(
-		ai.WithModel("test-model"),
-		ai.WithAPIKey("test-key"),
-		ai.WithBaseURL("https://test.com"),
-	)
-	if err != nil {
-		t.Fatalf("Init failed: %v", err)
-	}
-	opts := p.Options()
-	if opts.Model != "test-model" {
-		t.Errorf("Expected model 'test-model', got '%s'", opts.Model)
-	}
-	if opts.APIKey != "test-key" {
-		t.Errorf("Expected API key 'test-key', got '%s'", opts.APIKey)
-	}
-	if opts.BaseURL != "https://test.com" {
-		t.Errorf("Expected base URL 'https://test.com', got '%s'", opts.BaseURL)
-	}
-}
-
-func TestProvider_Defaults(t *testing.T) {
-	p := NewProvider()
-	opts := p.Options()
-	if opts.Model != "llama3.2" {
-		t.Errorf("Expected default model 'llama3.2', got '%s'", opts.Model)
-	}
-	if opts.BaseURL != "http://localhost:11434" {
-		t.Errorf("Expected default base URL 'http://localhost:11434', got '%s'", opts.BaseURL)
-	}
-}
-
-func TestProvider_IsCloud(t *testing.T) {
-	local := NewProvider(ai.WithBaseURL("http://localhost:11434"))
-	if local.isCloud() {
-		t.Error("localhost should not be cloud")
-	}
-	cloud := NewProvider(ai.WithBaseURL("https://ollama.com/v1"))
-	if !cloud.isCloud() {
-		t.Error("ollama.com should be cloud")
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Native mode (local Ollama: /api/chat)
-// ---------------------------------------------------------------------------
-
-func TestNative_Generate(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/api/chat" {
-			t.Errorf("Expected /api/chat, got %s", r.URL.Path)
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{
-			"model": "llama3.2",
-			"message": {"role": "assistant", "content": "Hello from local Ollama!"},
-			"done": true,
-			"prompt_eval_count": 10,
-			"eval_count": 5
-		}`))
-	}))
-	defer srv.Close()
-
-	p := NewProvider(ai.WithBaseURL(srv.URL), ai.WithModel("llama3.2"))
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt:       "Hi",
-		SystemPrompt: "You are helpful",
-	})
-	if err != nil {
-		t.Fatalf("Generate failed: %v", err)
-	}
-	if resp.Reply != "Hello from local Ollama!" {
-		t.Errorf("Expected 'Hello from local Ollama!', got '%s'", resp.Reply)
-	}
-	if resp.Usage.TotalTokens != 15 {
-		t.Errorf("Expected total tokens 15, got %d", resp.Usage.TotalTokens)
-	}
-}
-
-func TestNative_GenerateWithToolCall(t *testing.T) {
-	callCount := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		callCount++
-		w.Header().Set("Content-Type", "application/json")
-		if callCount == 1 {
-			w.Write([]byte(`{
-				"model": "llama3.2",
-				"message": {
-					"role": "assistant",
-					"content": "",
-					"tool_calls": [{"function": {"name": "get_weather", "arguments": "{\"city\":\"Seoul\"}"}}]
-				},
-				"done": true
-			}`))
-		} else {
-			w.Write([]byte(`{
-				"model": "llama3.2",
-				"message": {"role": "assistant", "content": "The weather in Seoul is sunny."},
-				"done": true
-			}`))
-		}
-	}))
-	defer srv.Close()
-
-	handler := func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		if call.Name != "get_weather" {
-			t.Errorf("Expected tool 'get_weather', got '%s'", call.Name)
-		}
-		return ai.ToolResult{ID: call.ID, Content: `{"temp": 22, "condition": "sunny"}`}
-	}
-
-	p := NewProvider(
-		ai.WithBaseURL(srv.URL),
-		ai.WithModel("llama3.2"),
-		ai.WithToolHandler(handler),
-	)
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "What's the weather?",
-		Tools: []ai.Tool{{
-			Name:        "get_weather",
-			Description: "Get weather",
-			Properties:  map[string]any{"city": map[string]any{"type": "string"}},
-		}},
-	})
-	if err != nil {
-		t.Fatalf("Generate failed: %v", err)
-	}
-	if len(resp.ToolCalls) == 0 {
-		t.Error("Expected tool calls")
-	}
-	if resp.Answer != "The weather in Seoul is sunny." {
-		t.Errorf("Expected final answer, got '%s'", resp.Answer)
-	}
-}
-
-func TestNative_Stream(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{"message":{"role":"assistant","content":"Hello"},"done":false}` + "\n"))
-		w.Write([]byte(`{"message":{"role":"assistant","content":" world"},"done":false}` + "\n"))
-		w.Write([]byte(`{"message":{"role":"assistant","content":""},"done":true}` + "\n"))
-	}))
-	defer srv.Close()
-
-	p := NewProvider(ai.WithBaseURL(srv.URL), ai.WithModel("llama3.2"))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hi"})
-	if err != nil {
-		t.Fatalf("Stream failed: %v", err)
-	}
-	defer stream.Close()
-
-	var chunks []string
-	for {
-		resp, err := stream.Recv()
-		if err != nil {
-			break
-		}
-		if resp.Reply != "" {
-			chunks = append(chunks, resp.Reply)
-		}
-	}
-	result := strings.Join(chunks, "")
-	if result != "Hello world" {
-		t.Errorf("Expected 'Hello world', got '%s'", result)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Cloud mode (Ollama Cloud: /v1/chat/completions)
-// ---------------------------------------------------------------------------
-
-func TestCloud_Generate(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Errorf("Expected /v1/chat/completions, got %s", r.URL.Path)
-		}
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{
-			"usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
-			"choices": [{"message": {"role": "assistant", "content": "Hello from Ollama Cloud!"}}]
-		}`))
-	}))
-	defer srv.Close()
-
-	p := NewProvider(ai.WithBaseURL(srv.URL), ai.WithModel("gemma4:31b-cloud"), ai.WithAPIKey("test-key"))
-	p.cloudOverride = true
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt:       "Hi",
-		SystemPrompt: "You are helpful",
-	})
-	if err != nil {
-		t.Fatalf("Generate failed: %v", err)
-	}
-	if resp.Reply != "Hello from Ollama Cloud!" {
-		t.Errorf("Expected 'Hello from Ollama Cloud!', got '%s'", resp.Reply)
-	}
-	if resp.Usage.TotalTokens != 15 {
-		t.Errorf("Expected total tokens 15, got %d", resp.Usage.TotalTokens)
-	}
-}
-
-func TestCloud_GenerateWithToolCall(t *testing.T) {
-	callCount := 0
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		callCount++
-		w.Header().Set("Content-Type", "application/json")
-		if callCount == 1 {
-			w.Write([]byte(`{
-				"choices": [{"message": {
-					"role": "assistant",
-					"content": "",
-					"tool_calls": [{"id": "call_1", "function": {"name": "search", "arguments": "{\"query\":\"go interfaces\"}"}}]
-				}}]
-			}`))
-		} else {
-			w.Write([]byte(`{
-				"choices": [{"message": {"role": "assistant", "content": "Go interfaces are implicit."}}]
-			}`))
-		}
-	}))
-	defer srv.Close()
-
-	handler := func(ctx context.Context, call ai.ToolCall) ai.ToolResult {
-		return ai.ToolResult{ID: call.ID, Content: `{"results": ["Go interfaces are implicit"]}`}
-	}
-
-	p := NewProvider(
-		ai.WithBaseURL(srv.URL),
-		ai.WithModel("gemma4:31b-cloud"),
-		ai.WithAPIKey("test-key"),
-		ai.WithToolHandler(handler),
-	)
-	p.cloudOverride = true
-	resp, err := p.Generate(context.Background(), &ai.Request{
-		Prompt: "Search for Go interfaces",
-		Tools: []ai.Tool{{
-			Name:        "search",
-			Description: "Search the knowledge base",
-			Properties:  map[string]any{"query": map[string]any{"type": "string"}},
-		}},
-	})
-	if err != nil {
-		t.Fatalf("Generate failed: %v", err)
-	}
-	if len(resp.ToolCalls) == 0 {
-		t.Error("Expected tool calls")
-	}
-	if resp.Answer != "Go interfaces are implicit." {
-		t.Errorf("Expected final answer, got '%s'", resp.Answer)
-	}
-}
-
-func TestCloud_Stream(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "text/event-stream")
-		w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"Hello\"}}]}\n\n"))
-		w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\" cloud\"}}]}\n\n"))
-		w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer srv.Close()
-
-	p := NewProvider(
-		ai.WithBaseURL(srv.URL),
-		ai.WithModel("gemma4:31b-cloud"),
-		ai.WithAPIKey("test-key"),
-	)
-	p.cloudOverride = true
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hi"})
-	if err != nil {
-		t.Fatalf("Stream failed: %v", err)
-	}
-	defer stream.Close()
-
-	var chunks []string
-	for {
-		resp, err := stream.Recv()
-		if err != nil {
-			break
-		}
-		if resp.Reply != "" {
-			chunks = append(chunks, resp.Reply)
-		}
-	}
-	result := strings.Join(chunks, "")
-	if result != "Hello cloud" {
-		t.Errorf("Expected 'Hello cloud', got '%s'", result)
-	}
-}
-
-// ---------------------------------------------------------------------------
-// Error handling
-// ---------------------------------------------------------------------------
-
-func TestProvider_APIError(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Write([]byte(`{"error": "model not found"}`))
-	}))
-	defer srv.Close()
-
-	p := NewProvider(ai.WithBaseURL(srv.URL), ai.WithModel("nonexistent"))
-	_, err := p.Generate(context.Background(), &ai.Request{Prompt: "Hi"})
-	if err == nil {
-		t.Error("Expected error on API failure")
-	}
-	if !strings.Contains(err.Error(), "API error") {
-		t.Errorf("Expected 'API error' in message, got '%s'", err.Error())
-	}
-}

ai/openai/openai.go

@@ -98,9 +98,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
@@ -162,13 +159,9 @@ func (p *Provider) Stream(ctx context.Context, req *ai.Request, opts ...ai.Gener
 		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
+		"model":    p.opts.Model,
+		"messages": messages,
+		"stream":   true,
 	}
 	reqBody, err := json.Marshal(apiReq)
 	if err != nil {
@@ -220,27 +213,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
@@ -285,7 +265,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 	// Read response
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	// Parse response

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

@@ -4,8 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"net/http"
-	"strconv"
 	"strings"
 	"time"
 )
@@ -15,70 +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
-}
-
-// HTTPError describes a failed provider HTTP response while preserving the
-// status code and Retry-After signal for retry classifiers.
-type HTTPError struct {
-	Status string
-	Code   int
-	Body   string
-	Header http.Header
-}
-
-func (e *HTTPError) Error() string {
-	if e == nil {
-		return ""
-	}
-	return fmt.Sprintf("API error (%s): %s", e.Status, e.Body)
-}
-
-func (e *HTTPError) StatusCode() int {
-	if e == nil {
-		return 0
-	}
-	return e.Code
-}
-
-func (e *HTTPError) RetryAfter() time.Duration {
-	if e == nil {
-		return 0
-	}
-	return parseRetryAfter(e.Header.Get("Retry-After"), time.Now())
-}
-
-func NewHTTPError(resp *http.Response, body []byte) error {
-	if resp == nil {
-		return errors.New("API error: nil response")
-	}
-	return &HTTPError{Status: resp.Status, Code: resp.StatusCode, Body: string(body), Header: resp.Header.Clone()}
-}
-
-func parseRetryAfter(value string, now time.Time) time.Duration {
-	value = strings.TrimSpace(value)
-	if value == "" {
-		return 0
-	}
-	if seconds, err := strconv.Atoi(value); err == nil {
-		if seconds <= 0 {
-			return 0
-		}
-		return time.Duration(seconds) * time.Second
-	}
-	when, err := http.ParseTime(value)
-	if err != nil {
-		return 0
-	}
-	if delay := when.Sub(now); delay > 0 {
-		return delay
-	}
-	return 0
-}
-
 // ErrorKind classifies provider-boundary failures into stable buckets callers
 // can inspect without parsing provider-specific error strings.
 type ErrorKind string
@@ -157,21 +91,17 @@ func GenerateWithRetry(ctx context.Context, m Model, req *Request, policy Genera
 			info.MaxAttempts = policy.MaxAttempts
 			callCtx = WithRunInfo(callCtx, info)
 		}
-		resp, err := generateAttempt(callCtx, m, req, opts...)
+		resp, err := m.Generate(callCtx, req, opts...)
 		cancel()
-
-		// Caller cancellation/deadline always wins and is not retried, even if
-		// a provider or tool loop swallowed the canceled tool result and returned
-		// a final response. This keeps agent runs from appearing successful after
-		// their controlling context was abandoned.
-		if ctxErr := ctx.Err(); ctxErr != nil {
-			return nil, ctxErr
-		}
 		if err == nil {
 			return resp, nil
 		}
 		last = err
 
+		// Caller cancellation/deadline always wins and is not retried.
+		if ctx.Err() != nil {
+			return nil, ctx.Err()
+		}
 		transient := IsTransientError(err)
 		if attempt == policy.MaxAttempts || !transient {
 			if attempt > 1 || transient {
@@ -183,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():
@@ -197,51 +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 generateAttempt(ctx context.Context, m Model, req *Request, opts ...GenerateOption) (*Response, error) {
-	if err := ctx.Err(); err != nil {
-		return nil, err
-	}
-	type result struct {
-		resp *Response
-		err  error
-	}
-	done := make(chan result, 1)
-	go func() {
-		resp, err := m.Generate(ctx, req, opts...)
-		done <- result{resp: resp, err: err}
-	}()
-	select {
-	case res := <-done:
-		return res.resp, res.err
-	case <-ctx.Done():
-		return nil, ctx.Err()
-	}
-}
-
-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

@@ -3,8 +3,6 @@ package ai
 import (
 	"context"
 	"errors"
-	"net/http"
-	"sync/atomic"
 	"testing"
 	"time"
 )
@@ -70,9 +68,9 @@ func TestGenerateWithRetryDoesNotRetryCallerCancellation(t *testing.T) {
 }
 
 func TestGenerateWithRetryHonorsPerAttemptTimeout(t *testing.T) {
-	var attempts atomic.Int32
+	attempts := 0
 	model := retryModel{generate: func(ctx context.Context, _ *Request, _ ...GenerateOption) (*Response, error) {
-		attempts.Add(1)
+		attempts++
 		<-ctx.Done()
 		return nil, ctx.Err()
 	}}
@@ -92,8 +90,8 @@ func TestGenerateWithRetryHonorsPerAttemptTimeout(t *testing.T) {
 	if !errors.Is(err, context.DeadlineExceeded) {
 		t.Fatalf("error = %v, want context.DeadlineExceeded", err)
 	}
-	if got := attempts.Load(); got != 2 {
-		t.Fatalf("attempts = %d, want 2", got)
+	if attempts != 2 {
+		t.Fatalf("attempts = %d, want 2", attempts)
 	}
 }
 
@@ -136,47 +134,11 @@ func TestGenerateWithRetryAddsAttemptMetadataToRunInfo(t *testing.T) {
 	}
 }
 
-func TestGenerateWithRetryReturnsWhenProviderIgnoresTimeout(t *testing.T) {
-	started := make(chan struct{})
-	release := make(chan struct{})
-	model := retryModel{generate: func(ctx context.Context, req *Request, opts ...GenerateOption) (*Response, error) {
-		close(started)
-		<-release
-		return &Response{Reply: "late"}, nil
-	}}
-	defer close(release)
-
-	start := time.Now()
-	_, err := GenerateWithRetry(context.Background(), model, &Request{Prompt: "hi"}, GeneratePolicy{
-		Timeout:     10 * time.Millisecond,
-		MaxAttempts: 1,
-	})
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Fatalf("GenerateWithRetry error = %v, want deadline exceeded", err)
-	}
-	if elapsed := time.Since(start); elapsed > 200*time.Millisecond {
-		t.Fatalf("GenerateWithRetry took %s after deadline, want prompt return", elapsed)
-	}
-	select {
-	case <-started:
-	default:
-		t.Fatal("provider was not called")
-	}
-}
-
 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
@@ -219,55 +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)
-	}
-}
-
-func TestHTTPErrorExposesStatusAndRetryAfter(t *testing.T) {
-	resp := &http.Response{
-		Status:     "429 Too Many Requests",
-		StatusCode: http.StatusTooManyRequests,
-		Header:     http.Header{"Retry-After": []string{"2"}},
-	}
-	err := NewHTTPError(resp, []byte("slow down"))
-
-	if got := ClassifyError(err); got != ErrorKindRateLimited {
-		t.Fatalf("ClassifyError() = %q, want %q", got, ErrorKindRateLimited)
-	}
-	var retryAfter RetryAfterCoder
-	if !errors.As(err, &retryAfter) {
-		t.Fatalf("NewHTTPError does not expose RetryAfterCoder")
-	}
-	if got := retryAfter.RetryAfter(); got != 2*time.Second {
-		t.Fatalf("RetryAfter() = %s, want 2s", got)
-	}
-}

ai/stream_conformance_test.go

@@ -1,310 +0,0 @@
-package ai_test
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-	"time"
-
-	"go-micro.dev/v6/ai"
-	_ "go-micro.dev/v6/ai/anthropic"
-	_ "go-micro.dev/v6/ai/atlascloud"
-	_ "go-micro.dev/v6/ai/gemini"
-	_ "go-micro.dev/v6/ai/groq"
-	_ "go-micro.dev/v6/ai/minimax"
-	_ "go-micro.dev/v6/ai/mistral"
-	_ "go-micro.dev/v6/ai/openai"
-	_ "go-micro.dev/v6/ai/together"
-)
-
-func TestStreamProvidersConformToOpenAICompatibleSSE(t *testing.T) {
-	providers := conformingStreamProviders(t)
-
-	for _, provider := range providers {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			var sawRequest bool
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				sawRequest = true
-				if r.URL.Path != "/v1/chat/completions" {
-					t.Fatalf("path = %s, want /v1/chat/completions", r.URL.Path)
-				}
-				if got := r.Header.Get("Accept"); got != "text/event-stream" {
-					t.Fatalf("Accept = %q, want text/event-stream", got)
-				}
-				if got := r.Header.Get("Authorization"); got != "Bearer test-key" {
-					t.Fatalf("Authorization = %q, want bearer API key", got)
-				}
-
-				var body map[string]any
-				if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-					t.Fatalf("decode request: %v", err)
-				}
-				if body["model"] == "" {
-					t.Fatal("request omitted model")
-				}
-				if body["stream"] != true {
-					t.Fatalf("stream = %#v, want true", body["stream"])
-				}
-				streamOptions, ok := body["stream_options"].(map[string]any)
-				if !ok || streamOptions["include_usage"] != true {
-					t.Fatalf("stream_options = %#v, want include_usage=true", body["stream_options"])
-				}
-				messages, ok := body["messages"].([]any)
-				if !ok || len(messages) != 4 {
-					t.Fatalf("messages = %#v, want system + history + prompt", body["messages"])
-				}
-				wantRoles := []string{"system", "user", "assistant", "user"}
-				for i, wantRole := range wantRoles {
-					message, ok := messages[i].(map[string]any)
-					if !ok || message["role"] != wantRole {
-						t.Fatalf("message[%d] = %#v, want role %q", i, messages[i], wantRole)
-					}
-				}
-
-				w.Header().Set("Content-Type", "text/event-stream")
-				_, _ = w.Write([]byte(": keepalive\n\n"))
-				_, _ = w.Write([]byte("event: ignored\n\n"))
-				_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-				_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-				_, _ = w.Write([]byte("data: {\"choices\":[],\"usage\":{\"prompt_tokens\":3,\"completion_tokens\":2,\"total_tokens\":5}}\n\n"))
-				_, _ = w.Write([]byte("data: [DONE]\n\n"))
-			}))
-			defer ts.Close()
-
-			model := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-			if model == nil {
-				t.Fatalf("ai.New(%q) returned nil", provider)
-			}
-			stream, err := model.Stream(context.Background(), &ai.Request{
-				SystemPrompt: "system",
-				Messages: []ai.Message{
-					{Role: "user", Content: "previous question"},
-					{Role: "assistant", Content: "previous answer"},
-				},
-				Prompt: "current question",
-			})
-			if err != nil {
-				t.Fatalf("Stream returned error: %v", err)
-			}
-			defer stream.Close()
-			if !sawRequest {
-				t.Fatal("server did not receive stream request")
-			}
-
-			assertStreamReply(t, stream, "hel")
-			assertStreamReply(t, stream, "lo")
-			usage, err := stream.Recv()
-			if err != nil {
-				t.Fatalf("usage chunk error: %v", err)
-			}
-			if usage.Reply != "" || usage.Usage != (ai.Usage{InputTokens: 3, OutputTokens: 2, TotalTokens: 5}) {
-				t.Fatalf("usage chunk = %#v", usage)
-			}
-			if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-				t.Fatalf("final error = %v, want EOF", err)
-			}
-		})
-	}
-}
-
-func TestStreamProvidersCloseCancelsInFlightRequest(t *testing.T) {
-	for _, provider := range conformingStreamProviders(t) {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			released := make(chan struct{})
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Header().Set("Content-Type", "text/event-stream")
-				_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-				if f, ok := w.(http.Flusher); ok {
-					f.Flush()
-				}
-				<-r.Context().Done()
-				close(released)
-			}))
-			defer ts.Close()
-
-			stream, err := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL)).Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-			if err != nil {
-				t.Fatalf("Stream returned error: %v", err)
-			}
-			assertStreamReply(t, stream, "hel")
-			if err := stream.Close(); err != nil {
-				t.Fatalf("Close returned error: %v", err)
-			}
-			if err := stream.Close(); err != nil {
-				t.Fatalf("second Close returned error: %v", err)
-			}
-
-			select {
-			case <-released:
-			case <-time.After(time.Second):
-				t.Fatal("server did not observe canceled stream request")
-			}
-		})
-	}
-}
-
-func TestStreamProvidersPropagateProviderErrors(t *testing.T) {
-	for _, provider := range conformingStreamProviders(t) {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				http.Error(w, "upstream quota exhausted", http.StatusTooManyRequests)
-			}))
-			defer ts.Close()
-
-			stream, err := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL)).Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-			if err == nil {
-				_ = stream.Close()
-				t.Fatal("Stream returned nil error for provider failure")
-			}
-			if !strings.Contains(err.Error(), "429") || !strings.Contains(err.Error(), "upstream quota exhausted") {
-				t.Fatalf("Stream error = %v, want provider status and body", err)
-			}
-			if strings.Contains(err.Error(), "test-key") {
-				t.Fatal("provider error leaked API key")
-			}
-		})
-	}
-}
-
-func TestStreamProvidersHonorCanceledContextBeforeRequest(t *testing.T) {
-	for _, provider := range conformingStreamProviders(t) {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			var sawRequest bool
-			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				sawRequest = true
-				http.Error(w, "unexpected request", http.StatusInternalServerError)
-			}))
-			defer ts.Close()
-
-			ctx, cancel := context.WithCancel(context.Background())
-			cancel()
-			stream, err := ai.New(provider, ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL)).Stream(ctx, &ai.Request{Prompt: "Hello"})
-			if err == nil {
-				_ = stream.Close()
-				t.Fatal("Stream returned nil error for canceled context")
-			}
-			if !errors.Is(err, context.Canceled) {
-				t.Fatalf("Stream error = %v, want context.Canceled", err)
-			}
-			if sawRequest {
-				t.Fatal("provider sent request after context was already canceled")
-			}
-		})
-	}
-}
-
-func TestConfiguredProviderStreamsSkipWithoutCredentials(t *testing.T) {
-	for _, tc := range []struct {
-		provider string
-		keyEnv   string
-		modelEnv string
-	}{
-		{provider: "openai", keyEnv: "OPENAI_API_KEY", modelEnv: "OPENAI_MODEL"},
-		{provider: "groq", keyEnv: "GROQ_API_KEY", modelEnv: "GROQ_MODEL"},
-		{provider: "mistral", keyEnv: "MISTRAL_API_KEY", modelEnv: "MISTRAL_MODEL"},
-		{provider: "together", keyEnv: "TOGETHER_API_KEY", modelEnv: "TOGETHER_MODEL"},
-		{provider: "atlascloud", keyEnv: "ATLASCLOUD_API_KEY", modelEnv: "ATLASCLOUD_MODEL"},
-		{provider: "anthropic", keyEnv: "ANTHROPIC_API_KEY", modelEnv: "ANTHROPIC_MODEL"},
-	} {
-		tc := tc
-		t.Run(tc.provider, func(t *testing.T) {
-			key := os.Getenv(tc.keyEnv)
-			if key == "" {
-				t.Skipf("%s not set; skipping configured provider stream check", tc.keyEnv)
-			}
-
-			opts := []ai.Option{ai.WithAPIKey(key)}
-			if model := os.Getenv(tc.modelEnv); model != "" {
-				opts = append(opts, ai.WithModel(model))
-			}
-			stream, err := ai.New(tc.provider, opts...).Stream(context.Background(), &ai.Request{Prompt: "Reply with exactly: ok"})
-			if err != nil {
-				t.Fatalf("Stream returned error: %v", err)
-			}
-			defer stream.Close()
-
-			deadline := time.After(30 * time.Second)
-			for {
-				select {
-				case <-deadline:
-					t.Fatal("timed out waiting for provider stream chunk")
-				default:
-				}
-				chunk, err := stream.Recv()
-				if err != nil {
-					if errors.Is(err, io.EOF) {
-						t.Fatal("provider stream ended without content")
-					}
-					t.Fatalf("Recv returned error: %v", err)
-				}
-				if chunk.Reply != "" {
-					return
-				}
-			}
-		})
-	}
-}
-
-func TestUnsupportedProvidersReturnStreamingUnsupportedAndStayUnregistered(t *testing.T) {
-	for _, provider := range []string{"gemini"} {
-		provider := provider
-		t.Run(provider, func(t *testing.T) {
-			if caps := ai.ProviderCapabilities(provider); caps.Stream {
-				t.Fatalf("ProviderCapabilities(%q).Stream = true, want false", provider)
-			}
-			_, err := ai.New(provider, ai.WithAPIKey("test-key")).Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-			if !errors.Is(err, ai.ErrStreamingUnsupported) {
-				t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
-			}
-			if err != nil && strings.Contains(err.Error(), "test-key") {
-				t.Fatal("streaming unsupported error leaked API key")
-			}
-		})
-	}
-}
-
-func conformingStreamProviders(t *testing.T) []string {
-	t.Helper()
-	providers := ai.RegisteredProviders("stream")
-	allowed := map[string]struct{}{
-		"atlascloud": {},
-		"groq":       {},
-		"minimax":    {},
-		"mistral":    {},
-		"openai":     {},
-		"together":   {},
-	}
-	var out []string
-	for _, provider := range providers {
-		if _, ok := allowed[provider]; ok {
-			out = append(out, provider)
-		}
-	}
-	want := []string{"atlascloud", "groq", "minimax", "mistral", "openai", "together"}
-	if !reflect.DeepEqual(out, want) {
-		t.Fatalf("conforming stream providers = %#v, want %#v (registered stream providers: %#v)", out, want, providers)
-	}
-	return out
-}
-
-func assertStreamReply(t *testing.T, stream ai.Stream, want string) {
-	t.Helper()
-	chunk, err := stream.Recv()
-	if err != nil {
-		t.Fatalf("Recv error = %v, want reply %q", err, want)
-	}
-	if chunk.Reply != want {
-		t.Fatalf("Reply = %q, want %q", chunk.Reply, want)
-	}
-}

ai/together/together.go

@@ -22,14 +22,12 @@ import (
 	"strings"
 
 	"go-micro.dev/v6/ai"
-	"go-micro.dev/v6/ai/internal/openaiapi"
 )
 
 func init() {
 	ai.Register("together", func(opts ...ai.Option) ai.Model {
 		return NewProvider(opts...)
 	})
-	ai.RegisterStream("together")
 }
 
 type Provider struct {
@@ -121,7 +119,7 @@ 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) {
-	return openaiapi.Stream(ctx, p.opts, req, "/v1/chat/completions")
+	return nil, fmt.Errorf("%w: together provider", ai.ErrStreamingUnsupported)
 }
 
 func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Response, map[string]any, error) {
@@ -147,7 +145,7 @@ func (p *Provider) callAPI(ctx context.Context, req map[string]any) (*ai.Respons
 
 	respBody, _ := io.ReadAll(httpResp.Body)
 	if httpResp.StatusCode != http.StatusOK {
-		return nil, nil, ai.NewHTTPError(httpResp, respBody)
+		return nil, nil, fmt.Errorf("API error (%s): %s", httpResp.Status, string(respBody))
 	}
 
 	var chatResp struct {

ai/together/together_test.go

@@ -2,11 +2,7 @@ package together
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"io"
-	"net/http"
-	"net/http/httptest"
 	"testing"
 
 	"go-micro.dev/v6/ai"
@@ -44,44 +40,9 @@ func TestProvider_Generate_NoAPIKey(t *testing.T) {
 	}
 }
 
-func TestProvider_Stream(t *testing.T) {
-	var sawStream bool
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/chat/completions" {
-			t.Fatalf("path = %s, want /v1/chat/completions", r.URL.Path)
-		}
-		var body map[string]any
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("decode request: %v", err)
-		}
-		sawStream, _ = body["stream"].(bool)
-		w.Header().Set("Content-Type", "text/event-stream")
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"hel\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: {\"choices\":[{\"delta\":{\"content\":\"lo\"}}]}\n\n"))
-		_, _ = w.Write([]byte("data: [DONE]\n\n"))
-	}))
-	defer ts.Close()
-
-	p := NewProvider(ai.WithAPIKey("test-key"), ai.WithBaseURL(ts.URL))
-	stream, err := p.Stream(context.Background(), &ai.Request{Prompt: "Hello"})
-	if err != nil {
-		t.Fatalf("Stream returned error: %v", err)
-	}
-	defer stream.Close()
-	if !sawStream {
-		t.Fatal("stream request did not set stream=true")
-	}
-
-	first, err := stream.Recv()
-	if err != nil || first.Reply != "hel" {
-		t.Fatalf("first chunk = %#v, %v; want hel", first, err)
-	}
-	second, err := stream.Recv()
-	if err != nil || second.Reply != "lo" {
-		t.Fatalf("second chunk = %#v, %v; want lo", second, err)
-	}
-	if _, err := stream.Recv(); !errors.Is(err, io.EOF) {
-		t.Fatalf("final error = %v, want EOF", err)
+func TestProvider_Stream_NotImplemented(t *testing.T) {
+	if _, err := NewProvider().Stream(context.Background(), &ai.Request{Prompt: "hi"}); !errors.Is(err, ai.ErrStreamingUnsupported) {
+		t.Fatalf("Stream error = %v, want ErrStreamingUnsupported", err)
 	}
 }
 

cmd/micro/README.md

@@ -52,26 +52,6 @@ This starts:
 
 Open http://localhost:8080 to see your services and call them from the browser.
 
-Call the generated service from another terminal:
-
-```
-curl -X POST http://localhost:8080/api/helloworld/Helloworld.Call \
-  -H 'Content-Type: application/json' -d '{"name":"World"}'
-```
-
-## First agent on-ramp
-
-Once the scaffold → run → call path works, ask the installed CLI for the
-provider-free agent path:
-
-```
-micro agent demo
-micro examples
-```
-
-Those commands point at the smallest mock-model first-agent example, the no-secret
-transcript, and the support app before you add provider-backed chat.
-
 ### Output
 
 ```
@@ -645,55 +625,3 @@ Scopes provide fine-grained access control over which tokens can call which serv
 The gateway's scope system uses `auth.Account` from the go-micro framework. Scopes on accounts are the same `[]string` field used by the framework's `auth.Rules` and `wrapper/auth` package. The gateway stores scope requirements in the default store under `endpoint-scopes/<service>.<endpoint>` keys and checks them on every HTTP request.
 
 For service-level (RPC) auth within the go-micro mesh, use the `wrapper/auth` package which provides `auth.Rules` with priority-based access control. See the [auth wrapper documentation](../../wrapper/auth/README.md) for details.
-
-## Self-improving loop (`micro loop`)
-
-Turn a repository into a self-improving one: GitHub Actions workflows that
-dispatch a coding agent to plan, build, and triage — gated by CI. This is the
-same loop that maintains go-micro itself, generalized so any repo (and any
-@mention-driven agent) can use it.
-
-```bash
-micro loop init      # scaffold the loop into the current repo
-micro loop verify    # check a repo is wired correctly
-```
-
-`micro loop init` writes the selected roles' workflows, their prompts, and a queue. Choose roles with `--roles` (default `planner,builder,triage`; `--roles all` for everything):
-
-| Role | Workflow | What it does |
-|------|----------|--------------|
-| Planner | `loop-planner.yml` | Keeps a ranked queue in `.github/loop/PRIORITIES.md` |
-| Builder | `loop-builder.yml` | Builds the top open item as a single-concern PR, auto-merged on green CI |
-| Triage | `loop-triage.yml` | Turns CI failures into scoped fix issues, back into the queue |
-| Coherence | `loop-coherence.yml` | Keeps README/docs/CHANGELOG aligned with the North Star *(opt-in)* |
-| Security | `loop-security.yml` | Audits for vulnerabilities and files them; never auto-merges fixes, never publishes exploit detail *(opt-in)* |
-| Release | `loop-release.yml` | Cuts the next patch tag when the branch has new commits *(opt-in)* |
-
-The workflows are the **mechanism**; each dispatch role's instruction is an editable file in `.github/loop/prompts/` — the **policy**. Edit those prompts (and `.github/loop/NORTH_STAR.md`) to steer the loop without touching the CLI. That split is what lets go-micro itself use `micro loop` while keeping its own richer prompts.
-
-Common flags:
-
-```bash
-micro loop init \
-  --roles all \
-  --agent @codex \
-  --token-secret LOOP_TOKEN \
-  --branch main \
-  --ci-workflow CI
-```
-
-- `--roles`: which roles to scaffold (`planner,builder,triage`, or `all`)
-- `--agent`: how the workflows summon the agent (an `@mention`)
-- `--token-secret`: repo secret holding the driving user PAT
-- `--branch`: base branch for the loop's PRs
-- `--ci-workflow`: `name:` of the CI workflow triage watches
-- `--tag-prefix`: tag prefix the release role matches and bumps (default `v`)
-
-Two things the CLI can't do for you (and `micro loop verify` reminds you of):
-
-1. **Add the token secret.** The agent ignores `@mentions` from the
-   `github-actions` bot, so dispatch posts as a real user via a PAT stored in
-   the `--token-secret` repo secret. The workflows no-op until it's set.
-2. **Set branch protection.** Require the CI checks with **0 approving reviews**
-   so the builder's native auto-merge lands PRs the moment CI is green — that
-   green-CI gate is the loop's only safety mechanism, so keep the suite strong.

cmd/micro/chat/chat.go

@@ -74,9 +74,7 @@ a new service automatically and start using it.
 
 Examples:
   ANTHROPIC_API_KEY=sk-ant-... micro chat --provider anthropic
-  micro chat --provider openai --prompt "list all users"
-  micro chat assistant --prompt "create a task"`,
-		ArgsUsage: "[agent]",
+  micro chat --provider openai --prompt "list all users"`,
 		Flags: []cli.Flag{
 			&cli.StringFlag{Name: "provider", Usage: "AI provider (anthropic, openai, gemini, groq, mistral, together, atlascloud)", EnvVars: []string{"MICRO_AI_PROVIDER"}},
 			&cli.StringFlag{Name: "api_key", Usage: "API key for the provider", EnvVars: []string{"MICRO_AI_API_KEY"}},
@@ -318,7 +316,6 @@ func run(c *cli.Context) error {
 	baseURL := c.String("base_url")
 	singlePrompt := c.String("prompt")
 	streamOutput := c.Bool("stream")
-	targetAgent := c.Args().First()
 
 	if provider == "" {
 		provider = ai.AutoDetectProvider(baseURL)
@@ -326,36 +323,15 @@ func run(c *cli.Context) error {
 	if apiKey == "" {
 		apiKey = fallbackAPIKey(provider)
 	}
+	if apiKey == "" {
+		return fmt.Errorf("no API key configured; set --api_key or %s", envVarForProvider(provider))
+	}
 
 	reg := registry.DefaultRegistry
 	cl := clt.DefaultClient
 
 	tools := ai.NewTools(reg, ai.ToolClient(cl))
 
-	s := &session{
-		provider: provider,
-		apiKey:   apiKey,
-		tools:    tools,
-		reg:      reg,
-		cl:       cl,
-		hist:     ai.NewHistory(50),
-		stream:   streamOutput,
-	}
-	hasAgents := s.discoverAgents()
-	if targetAgent != "" {
-		if _, ok := s.agents[targetAgent]; !ok {
-			return fmt.Errorf("agent %q is not registered; run `micro agent list` to see available agents", targetAgent)
-		}
-		s.agents = map[string]agentInfo{targetAgent: s.agents[targetAgent]}
-		hasAgents = true
-	}
-	if targetAgent != "" && singlePrompt != "" {
-		return s.ask(c.Context, singlePrompt)
-	}
-	if apiKey == "" {
-		return fmt.Errorf("no API key configured; set --api_key or %s", envVarForProvider(provider))
-	}
-
 	// Built-in agent capabilities (plan, delegate), reused from the
 	// agent package so the direct-service fallback matches a real agent.
 	builtinTools, builtinHandle := agent.Builtins(
@@ -367,8 +343,17 @@ func run(c *cli.Context) error {
 		agent.APIKey(apiKey),
 	)
 
-	s.builtinTools = builtinTools
-	s.builtinHandle = builtinHandle
+	s := &session{
+		provider:      provider,
+		apiKey:        apiKey,
+		tools:         tools,
+		reg:           reg,
+		cl:            cl,
+		hist:          ai.NewHistory(50),
+		builtinTools:  builtinTools,
+		builtinHandle: builtinHandle,
+		stream:        streamOutput,
+	}
 	s.refreshTools()
 
 	// Wrap the tool handler to intercept generate calls
@@ -402,6 +387,9 @@ func run(c *cli.Context) error {
 
 	defer s.cleanup()
 
+	// Discover registered agents
+	hasAgents := s.discoverAgents()
+
 	if singlePrompt != "" {
 		return s.ask(c.Context, singlePrompt)
 	}

cmd/micro/cli/agent/agent.go

@@ -14,31 +14,6 @@ import (
 	"go-micro.dev/v6/store"
 )
 
-const noSecretDemoHelp = `No-secret first-agent demo
-
-Use this when you want the fastest provider-free agent success path before
-configuring API keys. It runs the maintained support/first-agent transcript with
-the deterministic mock model used by CI:
-
-  go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1
-
-What this proves:
-  - service tools can be called by an agent
-  - chat behavior is exercised without contacting a live provider
-  - run history can be inspected after the prompt
-
-After it passes:
-  - Build your own service-backed agent: https://go-micro.dev/docs/guides/your-first-agent.html
-  - Diagnose provider-backed chat:     https://go-micro.dev/docs/guides/debugging-agents.html
-  - Walk the full 0→hero lifecycle:    https://go-micro.dev/docs/guides/zero-to-hero.html
-
-Use live-provider chat when you are ready for real model behavior:
-  micro agent preflight  # before micro run: prerequisites
-  micro run
-  micro chat
-  micro agent doctor     # after micro run: chat/gateway/inspect recovery
-  micro inspect agent <name>`
-
 func init() {
 	cmd.Register(&cli.Command{
 		Name:      "runs",
@@ -59,36 +34,8 @@ func init() {
 
 	cmd.Register(&cli.Command{
 		Name:  "agent",
-		Usage: "Manage AI agents (try: micro agent demo)",
+		Usage: "Manage AI agents",
 		Subcommands: []*cli.Command{
-			{
-				Name:  "demo",
-				Usage: "Show the no-secret first-agent demo command",
-				Description: `Print the provider-free first-agent path for new developers:
-the deterministic mock-model transcript, when to use it, and where to go next
-for live-provider chat and inspect/debugging.`,
-				Action: func(c *cli.Context) error {
-					fmt.Fprintln(c.App.Writer, noSecretDemoHelp)
-					return nil
-				},
-			},
-			{
-				Name:  "preflight",
-				Usage: "Check local prerequisites before the first provider-backed agent",
-				Action: func(c *cli.Context) error {
-					return runAgentPreflight(os.Stdout, defaultPreflightDeps())
-				},
-			},
-			{
-				Name:  "doctor",
-				Usage: "Diagnose chat, gateway, registration, provider, and inspect recovery after micro run",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "gateway", Value: "http://localhost:8080", Usage: "Gateway URL started by micro run"},
-				},
-				Action: func(c *cli.Context) error {
-					return runAgentDoctor(os.Stdout, defaultDoctorDeps(), c.String("gateway"))
-				},
-			},
 			{
 				Name:  "list",
 				Usage: "List registered agents",

cmd/micro/cli/agent/doctor.go

@@ -1,179 +0,0 @@
-package agent
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"time"
-
-	goagent "go-micro.dev/v6/agent"
-	"go-micro.dev/v6/registry"
-	"go-micro.dev/v6/store"
-)
-
-type doctorDeps struct {
-	getenv       func(string) string
-	httpGet      func(string) (*http.Response, error)
-	listServices func() ([]*registry.Service, error)
-	getService   func(string) ([]*registry.Service, error)
-	listRuns     func(string) ([]goagent.RunSummary, error)
-}
-
-func defaultDoctorDeps() doctorDeps {
-	client := &http.Client{Timeout: 2 * time.Second}
-	return doctorDeps{
-		getenv:       defaultPreflightDeps().getenv,
-		httpGet:      client.Get,
-		listServices: registry.ListServices,
-		getService:   registry.GetService,
-		listRuns: func(name string) ([]goagent.RunSummary, error) {
-			return goagent.ListRunSummariesWithOptions(store.DefaultStore, name, goagent.RunListOptions{Limit: 1})
-		},
-	}
-}
-
-func runAgentDoctor(w io.Writer, deps doctorDeps, gateway string) error {
-	if gateway == "" {
-		gateway = "http://localhost:8080"
-	}
-	gateway = strings.TrimRight(gateway, "/")
-	checks := agentDoctorChecks(deps, gateway)
-	failures := 0
-	fmt.Fprintln(w, "First-agent recovery doctor")
-	for _, check := range checks {
-		mark := "✓"
-		if !check.OK {
-			mark = "✗"
-			failures++
-		}
-		fmt.Fprintf(w, "  %s %s — %s\n", mark, check.Name, check.Detail)
-		if !check.OK && check.Fix != "" {
-			fmt.Fprintf(w, "    Fix: %s\n", check.Fix)
-		}
-		if !check.OK && check.Next != "" {
-			fmt.Fprintf(w, "    Next: %s\n", check.Next)
-		}
-	}
-	if failures > 0 {
-		return fmt.Errorf("first-agent doctor found %d recovery boundary issue(s)", failures)
-	}
-	fmt.Fprintln(w, "\nReady: gateway, agent registration, chat settings, and inspect history are reachable.")
-	return nil
-}
-
-func agentDoctorChecks(deps doctorDeps, gateway string) []preflightCheck {
-	if deps.getenv == nil {
-		deps.getenv = defaultPreflightDeps().getenv
-	}
-	if deps.httpGet == nil {
-		deps.httpGet = http.Get
-	}
-	if deps.listServices == nil {
-		deps.listServices = registry.ListServices
-	}
-	if deps.getService == nil {
-		deps.getService = registry.GetService
-	}
-	if deps.listRuns == nil {
-		deps.listRuns = func(name string) ([]goagent.RunSummary, error) {
-			return goagent.ListRunSummariesWithOptions(store.DefaultStore, name, goagent.RunListOptions{Limit: 1})
-		}
-	}
-
-	checks := []preflightCheck{checkGateway(deps, gateway), checkChatSettings(deps, gateway)}
-	agents, regCheck := checkAgentRegistration(deps)
-	checks = append(checks, regCheck)
-	checks = append(checks, checkRunHistory(deps, agents))
-	checks = append(checks, checkProviderConfig(deps))
-	return checks
-}
-
-func checkGateway(deps doctorDeps, gateway string) preflightCheck {
-	resp, err := deps.httpGet(gateway + "/agent")
-	if err != nil {
-		return preflightCheck{Name: "gateway /agent", Detail: err.Error(), Fix: "Start the local gateway with `micro run`, or pass the matching URL with `micro agent doctor --gateway http://localhost:<port>`.", Next: "Then open " + gateway + "/agent or retry `micro chat`."}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return preflightCheck{Name: "gateway /agent", Detail: fmt.Sprintf("%s returned %s", gateway+"/agent", resp.Status), Fix: "Confirm `micro run` is serving the web gateway and that auth/proxy settings are not blocking /agent.", Next: "See docs/guides/debugging-agents.html#chat-and-gateway-failures."}
-	}
-	return preflightCheck{Name: "gateway /agent", OK: true, Detail: gateway + "/agent is reachable"}
-}
-
-func checkChatSettings(deps doctorDeps, gateway string) preflightCheck {
-	resp, err := deps.httpGet(gateway + "/api/agent/settings")
-	if err != nil {
-		return preflightCheck{Name: "chat settings endpoint", Detail: err.Error(), Fix: "Keep `micro run` running and retry; the playground uses /api/agent/settings before chat prompts.", Next: "See docs/guides/debugging-agents.html#chat-and-gateway-failures."}
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return preflightCheck{Name: "chat settings endpoint", Detail: fmt.Sprintf("returned %s", resp.Status), Fix: "Check gateway auth/proxy configuration or use the Agent settings page to confirm chat settings load.", Next: "See docs/guides/debugging-agents.html#provider-failures."}
-	}
-	var settings map[string]string
-	_ = json.NewDecoder(resp.Body).Decode(&settings)
-	if settings["provider"] != "" || settings["model"] != "" || settings["api_key"] != "" {
-		return preflightCheck{Name: "chat settings endpoint", OK: true, Detail: "reachable with saved provider settings"}
-	}
-	return preflightCheck{Name: "chat settings endpoint", OK: true, Detail: "reachable; no saved provider settings"}
-}
-
-func checkAgentRegistration(deps doctorDeps) ([]string, preflightCheck) {
-	services, err := deps.listServices()
-	if err != nil {
-		return nil, preflightCheck{Name: "agent registration", Detail: err.Error(), Fix: "Keep the scaffolded agent process running under `micro run` and retry `micro agent list`.", Next: "See docs/guides/your-first-agent.html#run-your-agent."}
-	}
-	var agents []string
-	for _, svc := range services {
-		records, err := deps.getService(svc.Name)
-		if err != nil || len(records) == 0 {
-			continue
-		}
-		if serviceIsAgent(records[0]) {
-			agents = append(agents, svc.Name)
-		}
-	}
-	if len(agents) == 0 {
-		return nil, preflightCheck{Name: "agent registration", Detail: "no registered agent services found", Fix: "Start an agent project with `micro run` and confirm `micro agent list` shows it.", Next: "Use docs/guides/no-secret-first-agent.html for a deterministic no-provider agent."}
-	}
-	return agents, preflightCheck{Name: "agent registration", OK: true, Detail: "found " + strings.Join(agents, ", ")}
-}
-
-func serviceIsAgent(svc *registry.Service) bool {
-	if svc.Metadata != nil && svc.Metadata["type"] == "agent" {
-		return true
-	}
-	for _, node := range svc.Nodes {
-		if node.Metadata != nil && node.Metadata["type"] == "agent" {
-			return true
-		}
-	}
-	return false
-}
-
-func checkRunHistory(deps doctorDeps, agents []string) preflightCheck {
-	if len(agents) == 0 {
-		return preflightCheck{Name: "inspect run history", Detail: "skipped because no agent is registered", Fix: "Fix agent registration first, then chat once and run `micro inspect agent <name>`.", Next: "See docs/guides/debugging-agents.html#inspect-run-history."}
-	}
-	for _, name := range agents {
-		runs, err := deps.listRuns(name)
-		if err != nil {
-			return preflightCheck{Name: "inspect run history", Detail: err.Error(), Fix: "Ensure the local store is writable and retry `micro inspect agent " + name + "`.", Next: "See docs/guides/debugging-agents.html#inspect-run-history."}
-		}
-		if len(runs) > 0 {
-			return preflightCheck{Name: "inspect run history", OK: true, Detail: "recent runs available for " + name}
-		}
-	}
-	return preflightCheck{Name: "inspect run history", Detail: "no recorded agent runs yet", Fix: "Send one prompt with `micro chat` or the /agent playground, then run `micro inspect agent " + agents[0] + "`.", Next: "See docs/guides/your-first-agent.html#inspect-what-happened."}
-}
-
-func checkProviderConfig(deps doctorDeps) preflightCheck {
-	check := checkProviderKey(preflightDeps{getenv: deps.getenv})
-	check.Name = "provider configuration"
-	if !check.OK {
-		check.Detail = "no provider key found for live LLM chat"
-		check.Fix = "For provider-backed chat, export MICRO_AI_API_KEY or a provider-specific key; for no-secret recovery, use the mock-model walkthrough."
-	}
-	return check
-}

cmd/micro/cli/agent/doctor_test.go

@@ -1,75 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-
-	goagent "go-micro.dev/v6/agent"
-	"go-micro.dev/v6/registry"
-)
-
-func doctorHTTP(status int, body string) func(string) (*http.Response, error) {
-	return func(string) (*http.Response, error) {
-		return &http.Response{StatusCode: status, Status: "200 OK", Body: io.NopCloser(strings.NewReader(body))}, nil
-	}
-}
-
-func TestRunAgentDoctorPassesWhenRecoveryBoundariesReachable(t *testing.T) {
-	deps := doctorDeps{
-		getenv: func(key string) string {
-			if key == "MICRO_AI_API_KEY" {
-				return "set"
-			}
-			return ""
-		},
-		httpGet: doctorHTTP(200, `{"provider":"anthropic","model":"claude"}`),
-		listServices: func() ([]*registry.Service, error) {
-			return []*registry.Service{{Name: "assistant"}}, nil
-		},
-		getService: func(name string) ([]*registry.Service, error) {
-			return []*registry.Service{{Name: name, Metadata: map[string]string{"type": "agent"}}}, nil
-		},
-		listRuns: func(name string) ([]goagent.RunSummary, error) {
-			return []goagent.RunSummary{{RunID: "run-1", Status: "done"}}, nil
-		},
-	}
-	var out bytes.Buffer
-	if err := runAgentDoctor(&out, deps, "http://example.test"); err != nil {
-		t.Fatalf("runAgentDoctor() error = %v\n%s", err, out.String())
-	}
-	got := out.String()
-	for _, want := range []string{"First-agent recovery doctor", "✓ gateway /agent", "✓ chat settings endpoint", "✓ agent registration", "✓ inspect run history", "✓ provider configuration", "Ready:"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestRunAgentDoctorReportsActionableRecoveryFailures(t *testing.T) {
-	deps := doctorDeps{
-		getenv:  func(string) string { return "" },
-		httpGet: func(string) (*http.Response, error) { return nil, errors.New("connection refused") },
-		listServices: func() ([]*registry.Service, error) {
-			return []*registry.Service{{Name: "greeter"}}, nil
-		},
-		getService: func(name string) ([]*registry.Service, error) {
-			return []*registry.Service{{Name: name}}, nil
-		},
-		listRuns: func(name string) ([]goagent.RunSummary, error) { return nil, nil },
-	}
-	var out bytes.Buffer
-	err := runAgentDoctor(&out, deps, "http://localhost:8080")
-	if err == nil {
-		t.Fatal("runAgentDoctor() error = nil")
-	}
-	got := out.String()
-	for _, want := range []string{"✗ gateway /agent", "micro run", "✗ chat settings endpoint", "✗ agent registration", "micro agent list", "✗ inspect run history", "micro inspect agent <name>", "✗ provider configuration", "docs/guides/no-secret-first-agent.html"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}

cmd/micro/cli/agent/preflight.go

@@ -1,163 +0,0 @@
-package agent
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"os/exec"
-	"strings"
-
-	"go-micro.dev/v6/cmd"
-)
-
-type preflightCheck struct {
-	Name   string
-	OK     bool
-	Detail string
-	Fix    string
-	Next   string
-}
-
-type preflightDeps struct {
-	lookPath      func(string) (string, error)
-	commandOutput func(string, ...string) ([]byte, error)
-	executable    func() (string, error)
-	version       func() string
-	getenv        func(string) string
-	listen        func(string, string) (net.Listener, error)
-}
-
-func defaultPreflightDeps() preflightDeps {
-	return preflightDeps{
-		lookPath:      exec.LookPath,
-		commandOutput: func(name string, args ...string) ([]byte, error) { return exec.Command(name, args...).CombinedOutput() },
-		executable:    os.Executable,
-		version:       func() string { return cmd.App().Version },
-		getenv:        os.Getenv,
-		listen:        net.Listen,
-	}
-}
-
-func runAgentPreflight(w io.Writer, deps preflightDeps) error {
-	checks := agentPreflightChecks(deps)
-	failures := 0
-	fmt.Fprintln(w, "First-agent preflight")
-	for _, check := range checks {
-		mark := "✓"
-		if !check.OK {
-			mark = "✗"
-			failures++
-		}
-		fmt.Fprintf(w, "  %s %s — %s\n", mark, check.Name, check.Detail)
-		if !check.OK && check.Fix != "" {
-			fmt.Fprintf(w, "    Fix: %s\n", check.Fix)
-		}
-		if !check.OK && check.Next != "" {
-			fmt.Fprintf(w, "    Next: %s\n", check.Next)
-		}
-	}
-	if failures > 0 {
-		return fmt.Errorf("first-agent preflight failed: %d check(s) need attention", failures)
-	}
-	fmt.Fprintln(w, "\nReady for the first-agent walkthrough: micro run, then open http://localhost:8080/agent or use micro chat.")
-	return nil
-}
-
-func agentPreflightChecks(deps preflightDeps) []preflightCheck {
-	if deps.lookPath == nil {
-		deps.lookPath = exec.LookPath
-	}
-	if deps.commandOutput == nil {
-		deps.commandOutput = func(name string, args ...string) ([]byte, error) { return exec.Command(name, args...).CombinedOutput() }
-	}
-	if deps.executable == nil {
-		deps.executable = os.Executable
-	}
-	if deps.version == nil {
-		deps.version = func() string { return cmd.App().Version }
-	}
-	if deps.getenv == nil {
-		deps.getenv = os.Getenv
-	}
-	if deps.listen == nil {
-		deps.listen = net.Listen
-	}
-
-	checks := []preflightCheck{checkGoToolchain(deps), checkMicroBinary(deps), checkProviderKey(deps), checkPortAvailable(deps, ":8080", "micro run gateway and /agent playground")}
-	return checks
-}
-
-func checkGoToolchain(deps preflightDeps) preflightCheck {
-	path, err := deps.lookPath("go")
-	if err != nil {
-		return preflightCheck{Name: "Go toolchain", Detail: "go was not found on PATH", Fix: "Install Go 1.24 or newer from https://go.dev/doc/install and ensure go is on PATH.", Next: "After installing Go, rerun micro agent preflight, then continue with docs/guides/your-first-agent.html."}
-	}
-	out, err := deps.commandOutput("go", "version")
-	if err != nil {
-		return preflightCheck{Name: "Go toolchain", Detail: strings.TrimSpace(string(out)), Fix: "Ensure the go command runs successfully (try `go version`) before starting the agent walkthrough.", Next: "Use docs/guides/debugging-agents.html after the toolchain check passes if an agent run still fails."}
-	}
-	version := firstLine(out)
-	if !goVersionAtLeast(version, 1, 24) {
-		return preflightCheck{Name: "Go toolchain", Detail: fmt.Sprintf("%s (%s)", version, path), Fix: "Upgrade to Go 1.24 or newer before running generated services.", Next: "Rerun micro agent preflight, then continue with docs/guides/your-first-agent.html."}
-	}
-	return preflightCheck{Name: "Go toolchain", OK: true, Detail: fmt.Sprintf("%s (%s)", version, path)}
-}
-
-func checkMicroBinary(deps preflightDeps) preflightCheck {
-	exe, err := deps.executable()
-	if err != nil || exe == "" {
-		return preflightCheck{Name: "micro binary", Detail: "micro executable path is unavailable", Fix: "Install the micro CLI or run this check through `go run ./cmd/micro agent preflight` from the repository.", Next: "Then follow docs/getting-started.html for the scaffold -> run path."}
-	}
-	version := deps.version()
-	if version == "" {
-		version = "version unavailable"
-	}
-	return preflightCheck{Name: "micro binary", OK: true, Detail: fmt.Sprintf("%s (%s)", version, exe)}
-}
-
-func checkProviderKey(deps preflightDeps) preflightCheck {
-	keys := []string{"MICRO_AI_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GROQ_API_KEY", "MISTRAL_API_KEY", "TOGETHER_API_KEY", "ATLASCLOUD_API_KEY"}
-	var found []string
-	for _, k := range keys {
-		if deps.getenv(k) != "" {
-			found = append(found, k)
-		}
-	}
-	if len(found) == 0 {
-		return preflightCheck{Name: "provider API key", Detail: "no supported provider key found", Fix: "Export MICRO_AI_API_KEY or a provider key such as ANTHROPIC_API_KEY before running provider-backed agents.", Next: "For a no-secret path, run the mock-model walkthrough in docs/guides/no-secret-first-agent.html; for real providers, see docs/guides/debugging-agents.html#provider-failures."}
-	}
-	return preflightCheck{Name: "provider API key", OK: true, Detail: "found " + strings.Join(found, ", ")}
-}
-
-func checkPortAvailable(deps preflightDeps, addr, use string) preflightCheck {
-	ln, err := deps.listen("tcp", addr)
-	if err != nil {
-		return preflightCheck{Name: "local port " + addr, Detail: "busy or unavailable for " + use, Fix: "Stop the process using " + addr + " (for example, `lsof -i :8080`) or run `micro run --address` with a free port.", Next: "Once the gateway starts, open http://localhost:8080/agent or continue with docs/guides/your-first-agent.html#chat-with-your-agent."}
-	}
-	_ = ln.Close()
-	return preflightCheck{Name: "local port " + addr, OK: true, Detail: "available for " + use}
-}
-
-func firstLine(b []byte) string {
-	s := strings.TrimSpace(string(b))
-	if i := strings.IndexByte(s, '\n'); i >= 0 {
-		return s[:i]
-	}
-	return s
-}
-
-func goVersionAtLeast(line string, wantMajor, wantMinor int) bool {
-	idx := strings.Index(line, "go1.")
-	if idx < 0 {
-		return false
-	}
-	var major, minor int
-	if _, err := fmt.Sscanf(line[idx:], "go%d.%d", &major, &minor); err != nil {
-		return false
-	}
-	if major != wantMajor {
-		return major > wantMajor
-	}
-	return minor >= wantMinor
-}

cmd/micro/cli/agent/preflight_test.go

@@ -1,124 +0,0 @@
-package agent
-
-import (
-	"bytes"
-	"errors"
-	"net"
-	"strings"
-	"testing"
-)
-
-type stubListener struct{}
-
-func (stubListener) Accept() (net.Conn, error) { return nil, errors.New("closed") }
-func (stubListener) Close() error              { return nil }
-func (stubListener) Addr() net.Addr            { return stubAddr(":8080") }
-
-type stubAddr string
-
-func (a stubAddr) Network() string { return "tcp" }
-func (a stubAddr) String() string  { return string(a) }
-
-func TestRunAgentPreflightPassesWithKeyAndFreePort(t *testing.T) {
-	deps := preflightDeps{
-		lookPath: func(name string) (string, error) { return "/usr/bin/" + name, nil },
-		commandOutput: func(name string, args ...string) ([]byte, error) {
-			return []byte("go version go1.24.0 linux/amd64\n"), nil
-		},
-		executable: func() (string, error) { return "/usr/local/bin/micro", nil },
-		getenv: func(key string) string {
-			if key == "ANTHROPIC_API_KEY" {
-				return "set"
-			}
-			return ""
-		},
-		listen: func(network, address string) (net.Listener, error) { return stubListener{}, nil },
-	}
-
-	var out bytes.Buffer
-	if err := runAgentPreflight(&out, deps); err != nil {
-		t.Fatalf("runAgentPreflight() error = %v", err)
-	}
-	got := out.String()
-	for _, want := range []string{"First-agent preflight", "✓ Go toolchain", "✓ micro binary", "✓ provider API key", "✓ local port :8080", "Ready for the first-agent walkthrough"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestRunAgentPreflightReportsActionableFailures(t *testing.T) {
-	deps := preflightDeps{
-		lookPath:   func(name string) (string, error) { return "", errors.New("not found") },
-		executable: func() (string, error) { return "", errors.New("unknown") },
-		getenv:     func(key string) string { return "" },
-		listen:     func(network, address string) (net.Listener, error) { return nil, errors.New("in use") },
-	}
-
-	var out bytes.Buffer
-	err := runAgentPreflight(&out, deps)
-	if err == nil {
-		t.Fatal("runAgentPreflight() error = nil")
-	}
-	got := out.String()
-	for _, want := range []string{"✗ Go toolchain", "go was not found on PATH", "https://go.dev/doc/install", "docs/guides/your-first-agent.html", "✗ micro binary", "go run ./cmd/micro agent preflight", "✗ provider API key", "docs/guides/no-secret-first-agent.html", "docs/guides/debugging-agents.html#provider-failures", "✗ local port :8080", "lsof -i :8080", "micro run --address"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestRunAgentPreflightReportsOldGoVersion(t *testing.T) {
-	deps := preflightDeps{
-		lookPath: func(name string) (string, error) { return "/usr/bin/" + name, nil },
-		commandOutput: func(name string, args ...string) ([]byte, error) {
-			return []byte("go version go1.23.9 linux/amd64\n"), nil
-		},
-		executable: func() (string, error) { return "/usr/local/bin/micro", nil },
-		getenv: func(key string) string {
-			if key == "ANTHROPIC_API_KEY" {
-				return "set"
-			}
-			return ""
-		},
-		listen: func(network, address string) (net.Listener, error) { return stubListener{}, nil },
-	}
-
-	var out bytes.Buffer
-	err := runAgentPreflight(&out, deps)
-	if err == nil {
-		t.Fatal("runAgentPreflight() error = nil")
-	}
-	got := out.String()
-	for _, want := range []string{"✗ Go toolchain", "go1.23.9", "Upgrade to Go 1.24 or newer", "Rerun micro agent preflight"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestGoVersionAtLeast(t *testing.T) {
-	tests := []struct {
-		line string
-		want bool
-	}{
-		{line: "go version go1.24.0 linux/amd64", want: true},
-		{line: "go version go1.25.1 linux/amd64", want: true},
-		{line: "go version go1.23.9 linux/amd64", want: false},
-		{line: "unexpected", want: false},
-	}
-	for _, tt := range tests {
-		if got := goVersionAtLeast(tt.line, 1, 24); got != tt.want {
-			t.Fatalf("goVersionAtLeast(%q) = %v, want %v", tt.line, got, tt.want)
-		}
-	}
-}
-
-func TestFirstLine(t *testing.T) {
-	if got := firstLine([]byte("one\ntwo")); got != "one" {
-		t.Fatalf("firstLine() = %q", got)
-	}
-	if got := firstLine([]byte(" single ")); got != "single" {
-		t.Fatalf("firstLine() = %q", got)
-	}
-}

cmd/micro/cli/cli.go

@@ -24,88 +24,6 @@ import (
 	_ "go-micro.dev/v6/cmd/micro/cli/remote"
 )
 
-const zeroToHeroHelp = `0→hero no-secret lifecycle demo
-
-Run this from a go-micro repository checkout when you want one command that
-proves the maintained services → agents → workflows path without provider keys:
-
-  ./internal/harness/zero-to-hero-ci/run.sh
-
-That script runs the same deterministic path CI uses:
-  - CLI discovery for scaffold, run, chat, inspect, flow runs, and deploy dry-run
-  - the smallest first-agent example
-  - the support-desk reference app with services, an agent, a flow, and an approval gate
-  - plan/delegate and universe harnesses with only the model mocked
-
-If you only want the runnable examples first:
-  go run ./examples/first-agent
-  go run ./examples/support
-
-Full local contract:
-  make harness
-
-Guide: https://go-micro.dev/docs/guides/zero-to-hero.html`
-
-const examplesWayfinding = `First-agent examples (no provider key required)
-
-Run these from a go-micro repository checkout in this order. For the complete
-examples map, open examples/INDEX.md:
-
-  1. Smallest service-backed agent
-       go run ./examples/first-agent
-     Proves an agent can call a service tool with the deterministic mock model.
-
-  2. No-secret support-agent transcript
-       go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1
-     Exercises service tools, mock-model chat, and inspectable run history.
-
-  3. Full services → agents → workflows reference app
-       go run ./examples/support
-     Shows the support desk service, agent, workflow, and approval gate together.
-
-Then continue the same path with the installed CLI:
-  micro agent demo
-  micro docs
-  micro zero-to-hero
-
-Guides:
-  https://go-micro.dev/docs/guides/no-secret-first-agent.html
-  https://go-micro.dev/docs/guides/your-first-agent.html
-  https://go-micro.dev/docs/guides/debugging-agents.html
-  https://go-micro.dev/docs/guides/zero-to-hero.html`
-
-const docsWayfinding = `First-agent and 0→hero docs:
-
-  1. Start with the no-secret CLI demo
-       micro agent demo
-     This prints the maintained support-agent transcript command so you can
-     prove service tools, mock-model chat, and inspectable run history without
-     configuring a provider key.
-
-  2. No-secret first-agent transcript
-     https://go-micro.dev/docs/guides/no-secret-first-agent.html
-     Run the maintained support agent without a provider key:
-       go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1
-
-  3. Your First Agent
-     https://go-micro.dev/docs/guides/your-first-agent.html
-     Build a service-backed agent, then use:
-       micro agent preflight  # before micro run: prerequisites
-       micro run
-       micro chat
-       micro agent doctor     # after micro run: chat/gateway/inspect recovery
-
-  4. Debugging your agent
-     https://go-micro.dev/docs/guides/debugging-agents.html
-     Inspect agent runs and memory with:
-       micro agent doctor
-       micro inspect agent <name>
-       micro agent history <name>
-
-  5. 0→hero Reference
-     https://go-micro.dev/docs/guides/zero-to-hero.html
-     Walk the scaffold → run → chat → inspect → deploy dry-run lifecycle.`
-
 func genProtoHandler(c *cli.Context) error {
 	cmd := exec.Command("find", ".", "-name", "*.proto", "-exec", "protoc", "--proto_path=.", "--micro_out=.", "--go_out=.", `{}`, `;`)
 	cmd.Stdout = os.Stdout
@@ -178,39 +96,6 @@ func init() {
 				return nil
 			},
 		},
-
-		{
-			Name:  "examples",
-			Usage: "Show provider-free first-agent example paths",
-			Description: `Print the maintained no-secret examples for the services → agents →
-workflows on-ramp: first-agent, transcript, support app, and matching guides.`,
-			Action: func(ctx *cli.Context) error {
-				fmt.Fprintln(ctx.App.Writer, examplesWayfinding)
-				return nil
-			},
-		},
-		{
-			Name:  "zero-to-hero",
-			Usage: "Show the no-secret 0→hero lifecycle demo command",
-			Description: `Print the maintained provider-free services → agents → workflows
-lifecycle command and the smaller runnable examples it covers.`,
-			Aliases: []string{"hero"},
-			Action: func(ctx *cli.Context) error {
-				fmt.Fprintln(ctx.App.Writer, zeroToHeroHelp)
-				return nil
-			},
-		},
-		{
-			Name:  "docs",
-			Usage: "Show the first-agent and 0→hero documentation path",
-			Description: `Print the maintained adoption on-ramp for new Go Micro developers:
-the no-secret first-agent transcript, Your First Agent, debugging guide, and
-0→hero lifecycle reference.`,
-			Action: func(ctx *cli.Context) error {
-				fmt.Fprintln(ctx.App.Writer, docsWayfinding)
-				return nil
-			},
-		},
 		{
 			Name:  "call",
 			Usage: "Call a service",

cmd/micro/cli/deploy/deploy.go

@@ -43,9 +43,6 @@ func Deploy(c *cli.Context) error {
 	}
 
 	target, remotePath := resolveDeployTarget(c, target, cfg)
-	if c.Bool("dry-run") {
-		return printDeployPlan(c, target, cfg, remotePath)
-	}
 
 	return deploySSH(c, target, cfg, remotePath)
 }
@@ -99,81 +96,6 @@ func showDeployTargets(cfg *config.Config) error {
 	return fmt.Errorf("%s", sb.String())
 }
 
-func printDeployPlan(c *cli.Context, target string, cfg *config.Config, remotePath string) error {
-	dir := c.Args().Get(1)
-	if dir == "" {
-		dir = "."
-	}
-
-	absDir, err := filepath.Abs(dir)
-	if err != nil {
-		return fmt.Errorf("failed to get absolute path: %w", err)
-	}
-
-	if cfg == nil {
-		cfg, _ = config.Load(absDir)
-	}
-	if remotePath == "" {
-		remotePath = defaultRemotePath
-	}
-
-	services, err := deployServices(absDir, cfg, c.String("service"))
-	if err != nil {
-		return err
-	}
-
-	fmt.Println()
-	fmt.Println("  \033[1mmicro deploy --dry-run\033[0m")
-	fmt.Println()
-	fmt.Printf("  Target      \033[36m%s\033[0m\n", target)
-	fmt.Printf("  Remote path %s\n", remotePath)
-	fmt.Printf("  Services    %s\n", strings.Join(services, ", "))
-	fmt.Println()
-	fmt.Println("  Plan:")
-	fmt.Println("    1. Build linux/amd64 service binaries")
-	fmt.Printf("    2. Copy binaries to %s/bin/\n", remotePath)
-	fmt.Println("    3. Enable and restart micro@<service> systemd units")
-	fmt.Println("    4. Check service health")
-	fmt.Println()
-	fmt.Println("  No SSH, rsync, systemd, or remote deployment was performed.")
-	return nil
-}
-
-func deployServices(absDir string, cfg *config.Config, filterService string) ([]string, error) {
-	if filterService != "" && cfg != nil {
-		found := false
-		for _, svc := range cfg.Services {
-			if svc.Name == filterService {
-				found = true
-				break
-			}
-		}
-		if !found && len(cfg.Services) > 0 {
-			return nil, fmt.Errorf("service '%s' not found in configuration", filterService)
-		}
-	}
-
-	if cfg != nil && len(cfg.Services) > 0 {
-		sorted, err := cfg.TopologicalSort()
-		if err != nil {
-			return nil, err
-		}
-		services := make([]string, 0, len(sorted))
-		for _, svc := range sorted {
-			if filterService == "" || svc.Name == filterService {
-				services = append(services, svc.Name)
-			}
-		}
-		return services, nil
-	}
-
-	services := []string{filepath.Base(absDir)}
-	if filterService != "" && filterService != services[0] {
-		return nil, fmt.Errorf("service '%s' not found (only '%s' available)", filterService, services[0])
-	}
-	return services, nil
-}
-
 func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath string) error {
 	dir := c.Args().Get(1)
 	if dir == "" {
@@ -199,10 +121,19 @@ func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath str
 	fmt.Println()
 	fmt.Printf("  Target     \033[36m%s\033[0m\n\n", target)
 
-	// Early validation: resolve services before SSH checks.
-	services, err := deployServices(absDir, cfg, c.String("service"))
-	if err != nil {
-		return err
+	// Early validation: Check if the requested service exists before SSH checks
+	filterService := c.String("service")
+	if filterService != "" && cfg != nil {
+		found := false
+		for _, svc := range cfg.Services {
+			if svc.Name == filterService {
+				found = true
+				break
+			}
+		}
+		if !found && len(cfg.Services) > 0 {
+			return fmt.Errorf("service '%s' not found in configuration", filterService)
+		}
 	}
 
 	// Step 1: Check SSH connectivity
@@ -222,6 +153,28 @@ func deploySSH(c *cli.Context, target string, cfg *config.Config, remotePath str
 	fmt.Println("\u2713")
 
 	// Step 3: Build binaries
+	var services []string
+	if cfg != nil && len(cfg.Services) > 0 {
+		sorted, err := cfg.TopologicalSort()
+		if err != nil {
+			return err
+		}
+		for _, svc := range sorted {
+			// If --service flag is provided, only include that service
+			if filterService == "" || svc.Name == filterService {
+				services = append(services, svc.Name)
+			}
+		}
+	} else {
+		// Single service project
+		services = []string{filepath.Base(absDir)}
+
+		// If --service flag was provided for a single-service project, validate it matches
+		if filterService != "" && filterService != services[0] {
+			return fmt.Errorf("service '%s' not found (only '%s' available)", filterService, services[0])
+		}
+	}
+
 	fmt.Printf("  Building binaries...       ")
 	if err := buildBinaries(absDir, cfg, c.Bool("build"), services); err != nil {
 		fmt.Println("\u2717")
@@ -540,10 +493,6 @@ The deploy process:
 				Name:  "service",
 				Usage: "Deploy only a specific service (for multi-service projects)",
 			},
-			&cli.BoolFlag{
-				Name:  "dry-run",
-				Usage: "Print the deployment plan without building, connecting, copying, or restarting services",
-			},
 		},
 	})
 }

cmd/micro/cli/deploy/deploy_test.go

@@ -17,7 +17,6 @@ func newDeployTestContext(t *testing.T, args ...string) *cli.Context {
 	set.String("ssh", "", "")
 	set.String("service", "", "")
 	set.Bool("build", false, "")
-	set.Bool("dry-run", false, "")
 	if err := set.Parse(args); err != nil {
 		t.Fatalf("parse flags: %v", err)
 	}
@@ -119,49 +118,3 @@ deploy prod
 		t.Fatalf("deploy target = %#v", prod)
 	}
 }
-
-func TestDeployDryRunPlansConfiguredTargetWithoutRemoteSideEffects(t *testing.T) {
-	dir := t.TempDir()
-	if err := os.WriteFile(dir+"/micro.mu", []byte(`service api
-    path ./api
-
-deploy prod
-    ssh deploy@prod.example.com
-    path /srv/micro
-`), 0644); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	oldwd, err := os.Getwd()
-	if err != nil {
-		t.Fatalf("getwd: %v", err)
-	}
-	if err := os.Chdir(dir); err != nil {
-		t.Fatalf("chdir: %v", err)
-	}
-	t.Cleanup(func() {
-		if err := os.Chdir(oldwd); err != nil {
-			t.Errorf("restore cwd: %v", err)
-		}
-	})
-
-	ctx := newDeployTestContext(t, "--dry-run", "prod")
-	if err := Deploy(ctx); err != nil {
-		t.Fatalf("dry-run deploy: %v", err)
-	}
-}
-
-func TestDeployDryRunValidatesRequestedService(t *testing.T) {
-	ctx := newDeployTestContext(t, "--dry-run", "--service", "missing", "prod")
-	cfg := &config.Config{Services: map[string]*config.Service{
-		"api": {Name: "api", Path: "./api"},
-	}}
-
-	err := printDeployPlan(ctx, "deploy@prod.example.com", cfg, defaultRemotePath)
-	if err == nil {
-		t.Fatal("expected dry-run to validate service names")
-	}
-	if !strings.Contains(err.Error(), "service 'missing' not found in configuration") {
-		t.Fatalf("unexpected error: %v", err)
-	}
-}

cmd/micro/cli/new/contract_test.go

@@ -1,7 +1,6 @@
 package new
 
 import (
-	"bytes"
 	"errors"
 	"flag"
 	"os"
@@ -58,44 +57,6 @@ func TestZeroToOneNoMCPContract(t *testing.T) {
 	generated.call(t, "Bob", "Hello Bob")
 }
 
-func TestPrintNextStepsSurfacesFirstAgentPath(t *testing.T) {
-	var out bytes.Buffer
-	printNextSteps(&out, "helloworld", false)
-
-	for _, want := range []string{
-		"cd helloworld",
-		"micro agent preflight",
-		"go run .",
-		"micro chat",
-		"micro inspect agent <name>",
-		"micro agent demo",
-		"micro docs",
-		"your-first-agent.html",
-		"zero-to-hero.html",
-		"http://localhost:3001/mcp/tools",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("next steps missing %q:\n%s", want, out.String())
-		}
-	}
-}
-
-func TestPrintNextStepsNoMCPSkipsMCPHints(t *testing.T) {
-	var out bytes.Buffer
-	printNextSteps(&out, "worker", true)
-
-	for _, want := range []string{"micro agent preflight", "micro chat", "micro inspect agent <name>", "micro agent demo", "micro docs"} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("--no-mcp next steps missing %q:\n%s", want, out.String())
-		}
-	}
-	for _, notWant := range []string{"http://localhost:3001/mcp/tools", "micro mcp serve"} {
-		if strings.Contains(out.String(), notWant) {
-			t.Fatalf("--no-mcp next steps should not include %q:\n%s", notWant, out.String())
-		}
-	}
-}
-
 type generatedService struct {
 	dir      string
 	repoRoot string

cmd/micro/cli/new/new.go

@@ -6,7 +6,6 @@ import (
 	"context"
 	"fmt"
 	"go/build"
-	"io"
 	"os"
 	"os/exec"
 	"os/signal"
@@ -281,29 +280,16 @@ func Run(ctx *cli.Context) error {
 
 	fmt.Println()
 	fmt.Printf("  \033[32m✓\033[0m Service \033[36m%s\033[0m created\n\n", dir)
-	printNextSteps(os.Stdout, dir, noMCP)
-	return nil
-}
-
-func printNextSteps(w io.Writer, dir string, noMCP bool) {
-	fmt.Fprintln(w, "  Next steps:")
-	fmt.Fprintf(w, "    cd %s\n", dir)
-	fmt.Fprintln(w, "    micro agent preflight")
-	fmt.Fprintln(w, "    go run .")
-	fmt.Fprintln(w, "    micro chat")
-	fmt.Fprintln(w, "    micro inspect agent <name>")
-	fmt.Fprintln(w)
-	fmt.Fprintln(w, "  First-agent path:")
-	fmt.Fprintln(w, "    micro agent demo")
-	fmt.Fprintln(w, "    micro docs")
-	fmt.Fprintln(w, "    https://go-micro.dev/docs/guides/your-first-agent.html")
-	fmt.Fprintln(w, "    https://go-micro.dev/docs/guides/zero-to-hero.html")
+	fmt.Println("  Next steps:")
+	fmt.Printf("    cd %s\n", dir)
+	fmt.Println("    go run .")
 	if !noMCP {
-		fmt.Fprintln(w)
-		fmt.Fprintf(w, "    MCP tools   \033[36mhttp://localhost:3001/mcp/tools\033[0m\n")
-		fmt.Fprintln(w, "    Claude Code \033[2mmicro mcp serve\033[0m")
+		fmt.Println()
+		fmt.Printf("    MCP tools   \033[36mhttp://localhost:3001/mcp/tools\033[0m\n")
+		fmt.Println("    Claude Code \033[2mmicro mcp serve\033[0m")
 	}
-	fmt.Fprintln(w)
+	fmt.Println()
+	return nil
 }
 
 func selectTemplates(name string, noMCP bool) (mainTmpl, handlerTmpl, protoTmpl string) {

cmd/micro/examples_wayfinding_test.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/urfave/cli/v2"
-	microcmd "go-micro.dev/v6/cmd"
-)
-
-func TestExamplesWayfindingIndexStaysLinked(t *testing.T) {
-	root := filepath.Join("..", "..")
-	files := map[string]string{}
-	for _, name := range []string{"README.md", "examples/README.md", "examples/INDEX.md"} {
-		b, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(name)))
-		if err != nil {
-			t.Fatalf("read %s: %v", name, err)
-		}
-		files[name] = string(b)
-	}
-
-	for _, check := range []struct {
-		file string
-		want []string
-	}{
-		{
-			file: "README.md",
-			want: []string{"examples/INDEX.md", "examples/first-agent/", "examples/support/", "zero-to-hero.md"},
-		},
-		{
-			file: "examples/README.md",
-			want: []string{"./INDEX.md", "./first-agent/", "./support/", "./mcp/hello/", "./mcp/workflow/"},
-		},
-		{
-			file: "examples/INDEX.md",
-			want: []string{"go run ./examples/first-agent", "go run ./examples/support", "mcp/hello", "mcp/workflow", "flow-durable", "micro examples"},
-		},
-	} {
-		for _, want := range check.want {
-			if !strings.Contains(files[check.file], want) {
-				t.Fatalf("%s missing %q", check.file, want)
-			}
-		}
-	}
-}
-
-func TestExamplesCommandPointsAtWayfindingIndex(t *testing.T) {
-	examples := commandByName(t, "examples")
-	var out bytes.Buffer
-	app := cli.NewApp()
-	app.Writer = &out
-	if err := examples.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro examples failed: %v", err)
-	}
-
-	for _, want := range []string{
-		"examples/INDEX.md",
-		"go run ./examples/first-agent",
-		"go run ./examples/support",
-		"micro zero-to-hero",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro examples output missing %q:\n%s", want, out.String())
-		}
-	}
-
-	_ = microcmd.DefaultCmd // keep this test coupled to the registered command package.
-}

cmd/micro/first_agent_walkthrough_test.go

@@ -1,162 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/urfave/cli/v2"
-	microcmd "go-micro.dev/v6/cmd"
-)
-
-func TestFirstAgentWalkthroughCLIBoundaries(t *testing.T) {
-	commands := map[string]bool{}
-	subcommands := map[string]map[string]bool{}
-	for _, command := range microcmd.DefaultCmd.App().Commands {
-		commands[command.Name] = true
-		for _, subcommand := range command.Subcommands {
-			if subcommands[command.Name] == nil {
-				subcommands[command.Name] = map[string]bool{}
-			}
-			subcommands[command.Name][subcommand.Name] = true
-		}
-	}
-
-	for _, want := range []string{"new", "run", "chat", "inspect", "agent", "docs", "examples"} {
-		if !commands[want] {
-			t.Fatalf("first-agent walkthrough missing %q command", want)
-		}
-	}
-	if !subcommands["agent"]["preflight"] {
-		t.Fatal("first-agent walkthrough missing preflight boundary: agent preflight")
-	}
-	if !subcommands["agent"]["demo"] {
-		t.Fatal("first-agent walkthrough missing no-secret boundary: agent demo")
-	}
-	if !subcommands["agent"]["doctor"] {
-		t.Fatal("first-agent walkthrough missing recovery boundary: agent doctor")
-	}
-	if !subcommands["inspect"]["agent"] {
-		t.Fatal("first-agent walkthrough missing inspect boundary: inspect agent")
-	}
-
-	chat := commandByName(t, "chat")
-	if !strings.Contains(chat.Description, "services") || !strings.Contains(chat.Description, "agent") || !strings.Contains(chat.Description, `micro chat assistant --prompt`) {
-		t.Fatalf("micro chat should describe the service-to-agent walkthrough boundary; description was %q", chat.Description)
-	}
-
-	docs := commandByName(t, "docs")
-	if !strings.Contains(docs.Usage, "first-agent") || !strings.Contains(docs.Usage, "0→hero") {
-		t.Fatalf("micro docs should advertise the first-agent and 0→hero docs path; usage was %q", docs.Usage)
-	}
-	var out bytes.Buffer
-	app := cli.NewApp()
-	app.Writer = &out
-	if err := docs.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro docs failed: %v", err)
-	}
-	if demoIdx, guideIdx := strings.Index(out.String(), "micro agent demo"), strings.Index(out.String(), "no-secret-first-agent.html"); demoIdx < 0 || guideIdx < 0 || demoIdx > guideIdx {
-		t.Fatalf("micro docs should lead with micro agent demo before guide links:\n%s", out.String())
-	}
-	for _, want := range []string{
-		"micro agent demo",
-		"no-secret-first-agent.html",
-		"your-first-agent.html",
-		"debugging-agents.html",
-		"zero-to-hero.html",
-		"micro agent preflight  # before micro run: prerequisites",
-		"micro run",
-		"micro chat",
-		"micro agent doctor     # after micro run: chat/gateway/inspect recovery",
-		"micro inspect agent <name>",
-		"micro agent history <name>",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro docs output missing %q:\n%s", want, out.String())
-		}
-	}
-	if strings.Contains(out.String(), "micro runs") {
-		t.Fatalf("micro docs output should use the first-agent inspect command, not the legacy runs shortcut:\n%s", out.String())
-	}
-
-	examples := commandByName(t, "examples")
-	if !strings.Contains(examples.Usage, "first-agent") {
-		t.Fatalf("micro examples should advertise the first-agent examples path; usage was %q", examples.Usage)
-	}
-	out.Reset()
-	if err := examples.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro examples failed: %v", err)
-	}
-	for _, want := range []string{
-		"First-agent examples",
-		"go run ./examples/first-agent",
-		"go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1",
-		"go run ./examples/support",
-		"micro agent demo",
-		"micro docs",
-		"micro zero-to-hero",
-		"no-secret-first-agent.html",
-		"your-first-agent.html",
-		"debugging-agents.html",
-		"zero-to-hero.html",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro examples output missing %q:\n%s", want, out.String())
-		}
-	}
-
-	agent := commandByName(t, "agent")
-	if !strings.Contains(agent.Usage, "micro agent demo") {
-		t.Fatalf("micro agent help should advertise the no-secret demo; usage was %q", agent.Usage)
-	}
-	doctor := subcommandByName(t, agent, "doctor")
-	for _, want := range []string{"chat", "gateway", "registration", "provider", "inspect", "after micro run"} {
-		if !strings.Contains(doctor.Usage, want) {
-			t.Fatalf("micro agent doctor usage should advertise after-run recovery for %q; usage was %q", want, doctor.Usage)
-		}
-	}
-
-	demo := subcommandByName(t, agent, "demo")
-	out.Reset()
-	if err := demo.Action(cli.NewContext(app, nil, nil)); err != nil {
-		t.Fatalf("micro agent demo failed: %v", err)
-	}
-	for _, want := range []string{
-		"No-secret first-agent demo",
-		"go test ./internal/harness/zero-to-hero-ci -run TestNoSecretFirstAgentTranscript -count=1",
-		"provider-free",
-		"micro agent preflight  # before micro run: prerequisites",
-		"micro chat",
-		"micro agent doctor     # after micro run: chat/gateway/inspect recovery",
-		"micro inspect agent <name>",
-		"your-first-agent.html",
-		"debugging-agents.html",
-		"zero-to-hero.html",
-	} {
-		if !strings.Contains(out.String(), want) {
-			t.Fatalf("micro agent demo output missing %q:\n%s", want, out.String())
-		}
-	}
-}
-
-func commandByName(t *testing.T, name string) *cli.Command {
-	t.Helper()
-	for _, command := range microcmd.DefaultCmd.App().Commands {
-		if command.Name == name {
-			return command
-		}
-	}
-	t.Fatalf("missing command %q", name)
-	return nil
-}
-
-func subcommandByName(t *testing.T, command *cli.Command, name string) *cli.Command {
-	t.Helper()
-	for _, subcommand := range command.Subcommands {
-		if subcommand.Name == name {
-			return subcommand
-		}
-	}
-	t.Fatalf("missing subcommand %q under %q", name, command.Name)
-	return nil
-}

cmd/micro/inspect/inspect.go

@@ -1,190 +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.Checkpoint != "" {
-			fmt.Fprintf(w, "  checkpoint=%s", run.Checkpoint)
-		}
-		if run.Stage != "" {
-			fmt.Fprintf(w, "  stage=%s", run.Stage)
-		}
-		if run.LastError != "" {
-			fmt.Fprintf(w, "  error=%q", run.LastError)
-		}
-		if run.TraceID != "" {
-			fmt.Fprintf(w, "  trace=%s", shortID(run.TraceID))
-		}
-		fmt.Fprintln(w)
-		if isResumableAgentRun(run) {
-			fmt.Fprintf(w, "    resume: call micro.AgentResume(ctx, agent, %q) after recreating the agent with the same checkpoint store\n", run.RunID)
-		}
-		if run.Stage == "input-required" {
-			fmt.Fprintf(w, "    input:  call micro.AgentResumeInput(ctx, agent, %q, input) to continue the paused run\n", run.RunID)
-		}
-	}
-	return nil
-}
-
-func isResumableAgentRun(run goagent.RunSummary) bool {
-	switch run.Status {
-	case "running", "error", "failed", "refused":
-		return run.Checkpoint != "done" || run.Stage != ""
-	default:
-		return false
-	}
-}
-
-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,78 +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", Checkpoint: "failed", Stage: "ask"}}
-	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", "checkpoint=failed", "stage=ask", `error="boom"`, "trace=1234567890ab", `micro.AgentResume(ctx, agent, "run-1")`} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("output missing %q:\n%s", want, got)
-		}
-	}
-}
-
-func TestWriteAgentInspectionIncludesInputResumeBreadcrumb(t *testing.T) {
-	runs := []goagent.RunSummary{{RunID: "run-input", Status: "running", Events: 3, LastKind: "checkpoint", Checkpoint: "paused", Stage: "input-required"}}
-	var out bytes.Buffer
-	if err := writeAgentInspection(&out, "support", runs, false); err != nil {
-		t.Fatal(err)
-	}
-	got := out.String()
-	for _, want := range []string{"checkpoint=paused", "stage=input-required", `micro.AgentResumeInput(ctx, agent, "run-input", input)`} {
-		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/loop/loop.go

@@ -1,497 +0,0 @@
-// Package loop implements the 'micro loop' command, which scaffolds and
-// verifies an autonomous improvement loop for a repository.
-//
-// The loop is a set of GitHub Actions workflows that dispatch a coding agent by
-// @mention on a fresh tracking issue each run. It has up to five roles:
-//
-//	planner    keeps a ranked queue in .github/loop/PRIORITIES.md
-//	builder    builds the top open item as a single-concern PR (auto-merged on green CI)
-//	triage     turns CI failures into scoped fix issues back into the queue
-//	coherence  keeps README/docs/CHANGELOG aligned with the North Star (opt-in)
-//	release    cuts the next patch tag when the branch has new commits (opt-in)
-//
-// The workflows are the MECHANISM; each dispatch role's instruction lives in an
-// editable .github/loop/prompts/<role>.md file — the POLICY. That split is what
-// lets any repo (including go-micro itself) customize behavior by editing prompt
-// files rather than forking the CLI. `micro loop init` writes it all; `micro
-// loop verify` checks the wiring.
-package loop
-
-import (
-	"bytes"
-	"embed"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"sort"
-	"strings"
-	"text/template"
-
-	"github.com/urfave/cli/v2"
-	"go-micro.dev/v6/cmd"
-)
-
-//go:embed templates/*
-var templatesFS embed.FS
-
-// config is the substitution surface for the templates — the whole config-vs-core
-// boundary. The workflows and prompts are the reusable core; these are what a
-// given repo tunes.
-type config struct {
-	// Shared.
-	DefaultBranch   string // base branch for the loop's PRs (e.g. main)
-	AgentMention    string // how the workflows summon the agent (e.g. @codex)
-	TokenSecret     string // repo secret holding the user PAT that drives dispatch
-	CIWorkflow      string // human-readable CI workflow name(s) triage watches
-	CIWorkflowsYAML string // the same as a YAML array literal, e.g. ["Lint", "Run Tests"]
-
-	// Per-dispatch-role (set while rendering each one).
-	Role         string
-	WorkflowName string
-	IssueTitle   string
-	Group        string
-	Cron         string
-
-	// Release role.
-	TagPrefix   string // tag prefix to match/bump, e.g. "v"
-	ReleaseCron string
-}
-
-// dispatchRole is a cron-driven role rendered from templates/dispatch.yml.tmpl.
-type dispatchRole struct {
-	workflowName string
-	issueTitle   string
-	group        string
-	cronFlag     string
-	defaultCron  string
-}
-
-var dispatchRoles = map[string]dispatchRole{
-	"planner":   {"Loop: Planner", "Loop: planning review", "loop-planner", "planner-cron", "0 * * * *"},
-	"builder":   {"Loop: Builder", "Loop: build increment", "loop-builder", "builder-cron", "30 * * * *"},
-	"coherence": {"Loop: Coherence", "Loop: coherence review", "loop-coherence", "coherence-cron", "0 7 * * *"},
-	"security":  {"Loop: Security", "Loop: security review", "loop-security", "security-cron", "0 6 * * 1"},
-}
-
-// allRoles is the full set, in a stable order, for --roles=all and help text.
-var allRoles = []string{"planner", "builder", "triage", "coherence", "security", "release"}
-
-const (
-	promptDir = ".github/loop/prompts"
-	loopDir   = ".github/loop"
-	wfDir     = ".github/workflows"
-)
-
-func init() {
-	cmd.Register(&cli.Command{
-		Name:  "loop",
-		Usage: "Scaffold an autonomous improvement loop for a repository",
-		Description: `Set up a self-improving loop for a repo: GitHub Actions workflows that
-dispatch a coding agent to plan, build, triage, and (optionally) keep docs
-coherent and cut releases — gated by CI.
-
-Roles (choose with --roles, default: planner,builder,triage):
-  planner    keeps a ranked queue in .github/loop/PRIORITIES.md
-  builder    builds the top open item as a single-concern PR (auto-merged on green CI)
-  triage     turns CI failures into scoped fix issues back into the queue
-  coherence  keeps README/docs/CHANGELOG aligned with the North Star
-  security   audits for vulnerabilities and files them (fixes stay human-reviewed)
-  release    cuts the next patch tag when the branch has new commits
-
-Each dispatch role's instruction is an editable file in .github/loop/prompts/ —
-edit those to steer behavior. Direction lives in .github/loop/NORTH_STAR.md.
-
-Examples:
-  # Scaffold the default loop (planner, builder, triage)
-  micro loop init
-
-  # The full loop, all five roles
-  micro loop init --roles all
-
-  # Customize the agent, token secret, base branch, and CI workflow name
-  micro loop init --agent @codex --token-secret LOOP_TOKEN \
-    --branch main --ci-workflow CI
-
-  # Check that a repo is wired correctly
-  micro loop verify`,
-		Subcommands: []*cli.Command{
-			{
-				Name:  "init",
-				Usage: "Scaffold the loop workflows, prompts, and queue into a repo",
-				Flags: []cli.Flag{
-					&cli.StringFlag{Name: "dir", Usage: "Target repo directory", Value: "."},
-					&cli.StringFlag{Name: "roles", Usage: "Comma-separated roles, or 'all'", Value: "planner,builder,triage"},
-					&cli.StringFlag{Name: "branch", Usage: "Base branch for the loop's PRs (auto-detected if empty)"},
-					&cli.StringFlag{Name: "agent", Usage: "How the workflows summon the agent (an @mention)", Value: "@codex"},
-					&cli.StringFlag{Name: "token-secret", Usage: "Repo secret holding the user PAT that drives dispatch", Value: "LOOP_TOKEN"},
-					&cli.StringFlag{Name: "ci-workflow", Usage: "CI workflow name(s) triage watches for failures (comma-separated)", Value: "CI"},
-					&cli.StringFlag{Name: "planner-cron", Usage: "Cron schedule for the planner", Value: "0 * * * *"},
-					&cli.StringFlag{Name: "builder-cron", Usage: "Cron schedule for the builder", Value: "30 * * * *"},
-					&cli.StringFlag{Name: "coherence-cron", Usage: "Cron schedule for the coherence role", Value: "0 7 * * *"},
-					&cli.StringFlag{Name: "security-cron", Usage: "Cron schedule for the security role", Value: "0 6 * * 1"},
-					&cli.StringFlag{Name: "release-cron", Usage: "Cron schedule for the release role", Value: "0 23 * * *"},
-					&cli.StringFlag{Name: "tag-prefix", Usage: "Tag prefix the release role matches and bumps", Value: "v"},
-					&cli.BoolFlag{Name: "force", Usage: "Overwrite existing loop files"},
-				},
-				Action: runInit,
-			},
-			{
-				Name:   "verify",
-				Usage:  "Verify a repo is wired for the loop",
-				Flags:  []cli.Flag{&cli.StringFlag{Name: "dir", Usage: "Target repo directory", Value: "."}},
-				Action: runVerify,
-			},
-		},
-	})
-}
-
-func runInit(c *cli.Context) error {
-	dir := c.String("dir")
-	roles, err := parseRoles(c.String("roles"))
-	if err != nil {
-		return err
-	}
-
-	ciNames := splitCSV(c.String("ci-workflow"))
-	cfg := config{
-		DefaultBranch:   c.String("branch"),
-		AgentMention:    strings.TrimSpace(c.String("agent")),
-		TokenSecret:     strings.TrimSpace(c.String("token-secret")),
-		CIWorkflow:      strings.Join(ciNames, ", "),
-		CIWorkflowsYAML: yamlStringArray(ciNames),
-		TagPrefix:       c.String("tag-prefix"),
-		ReleaseCron:     c.String("release-cron"),
-	}
-	if cfg.DefaultBranch == "" {
-		cfg.DefaultBranch = detectDefaultBranch(dir)
-	}
-	if !strings.HasPrefix(cfg.AgentMention, "@") {
-		cfg.AgentMention = "@" + cfg.AgentMention
-	}
-
-	crons := map[string]string{
-		"planner":   c.String("planner-cron"),
-		"builder":   c.String("builder-cron"),
-		"coherence": c.String("coherence-cron"),
-		"security":  c.String("security-cron"),
-	}
-
-	if err := scaffold(dir, cfg, roles, crons, c.Bool("force")); err != nil {
-		return err
-	}
-	printNextSteps(cfg, roles)
-	return nil
-}
-
-// parseRoles resolves the --roles flag into a validated, stable-ordered set.
-func parseRoles(spec string) ([]string, error) {
-	if strings.TrimSpace(spec) == "all" {
-		return append([]string(nil), allRoles...), nil
-	}
-	want := map[string]bool{}
-	for _, r := range strings.Split(spec, ",") {
-		r = strings.TrimSpace(r)
-		if r == "" {
-			continue
-		}
-		if !isRole(r) {
-			return nil, fmt.Errorf("unknown role %q (valid: %s, or 'all')", r, strings.Join(allRoles, ", "))
-		}
-		want[r] = true
-	}
-	if len(want) == 0 {
-		return nil, fmt.Errorf("no roles selected")
-	}
-	var out []string
-	for _, r := range allRoles { // preserve canonical order
-		if want[r] {
-			out = append(out, r)
-		}
-	}
-	return out, nil
-}
-
-// splitCSV splits a comma-separated flag into trimmed, non-empty values.
-func splitCSV(s string) []string {
-	var out []string
-	for _, v := range strings.Split(s, ",") {
-		if v = strings.TrimSpace(v); v != "" {
-			out = append(out, v)
-		}
-	}
-	if len(out) == 0 {
-		out = []string{"CI"}
-	}
-	return out
-}
-
-// yamlStringArray renders names as a YAML/JSON flow array, e.g. ["Lint", "Run Tests"].
-// Names are known workflow display names (no embedded quotes), so a simple quote is safe.
-func yamlStringArray(names []string) string {
-	quoted := make([]string, len(names))
-	for i, n := range names {
-		quoted[i] = fmt.Sprintf("%q", n)
-	}
-	return "[" + strings.Join(quoted, ", ") + "]"
-}
-
-func isRole(r string) bool {
-	for _, x := range allRoles {
-		if x == r {
-			return true
-		}
-	}
-	return false
-}
-
-// scaffold renders the selected roles into dir. The split is deliberate:
-//   - Workflows are the MECHANISM — regenerated, and overwritten with --force.
-//   - Prompts, NORTH_STAR, and PRIORITIES are the POLICY — written once and
-//     never clobbered, even with --force, so re-running init to refresh the
-//     workflow mechanics can't wipe curated instructions, direction, or queue.
-func scaffold(dir string, cfg config, roles []string, crons map[string]string, force bool) error {
-	for _, role := range roles {
-		switch role {
-		case "triage":
-			if err := renderTo(dir, "templates/loop-triage.yml.tmpl", filepath.Join(wfDir, "loop-triage.yml"), cfg, force); err != nil {
-				return err
-			}
-			if err := renderKeep(dir, "templates/prompts/triage.md.tmpl", filepath.Join(promptDir, "triage.md"), cfg); err != nil {
-				return err
-			}
-		case "release":
-			if err := renderTo(dir, "templates/loop-release.yml.tmpl", filepath.Join(wfDir, "loop-release.yml"), cfg, force); err != nil {
-				return err
-			}
-		default: // dispatch roles
-			d := dispatchRoles[role]
-			rc := cfg
-			rc.Role = role
-			rc.WorkflowName = d.workflowName
-			rc.IssueTitle = d.issueTitle
-			rc.Group = d.group
-			rc.Cron = crons[role]
-			if rc.Cron == "" {
-				rc.Cron = d.defaultCron
-			}
-			if err := renderTo(dir, "templates/dispatch.yml.tmpl", filepath.Join(wfDir, "loop-"+role+".yml"), rc, force); err != nil {
-				return err
-			}
-			if err := renderKeep(dir, "templates/prompts/"+role+".md.tmpl", filepath.Join(promptDir, role+".md"), cfg); err != nil {
-				return err
-			}
-		}
-	}
-
-	// Direction + queue: policy, written once, never clobbered.
-	if err := renderKeep(dir, "templates/NORTH_STAR.md", filepath.Join(loopDir, "NORTH_STAR.md"), cfg); err != nil {
-		return err
-	}
-	return renderKeep(dir, "templates/PRIORITIES.md", filepath.Join(loopDir, "PRIORITIES.md"), cfg)
-}
-
-// renderTo renders a template with cfg and writes it to dir/dest (honoring force).
-func renderTo(dir, tmplName, dest string, cfg config, force bool) error {
-	rendered, err := render(tmplName, cfg)
-	if err != nil {
-		return err
-	}
-	if err := writeFile(filepath.Join(dir, dest), rendered, force); err != nil {
-		return err
-	}
-	fmt.Printf("  wrote %s\n", dest)
-	return nil
-}
-
-// renderKeep writes dir/dest only if it does not already exist — used for
-// policy files (prompts, North Star, queue) so re-running init never clobbers
-// customizations, regardless of --force.
-func renderKeep(dir, tmplName, dest string, cfg config) error {
-	full := filepath.Join(dir, dest)
-	if fileExists(full) {
-		fmt.Printf("  kept  %s (already exists)\n", dest)
-		return nil
-	}
-	rendered, err := render(tmplName, cfg)
-	if err != nil {
-		return err
-	}
-	if err := writeFile(full, rendered, true); err != nil {
-		return err
-	}
-	fmt.Printf("  wrote %s\n", dest)
-	return nil
-}
-
-// verifyState reports what's wrong with dir's loop setup: warnings are
-// non-fatal, missing are required files that aren't present.
-func verifyState(dir string) (warnings, missing []string) {
-	// A loop needs direction, a queue, and at least one role workflow.
-	for _, dest := range []string{filepath.Join(loopDir, "NORTH_STAR.md"), filepath.Join(loopDir, "PRIORITIES.md")} {
-		if !fileExists(filepath.Join(dir, dest)) {
-			missing = append(missing, dest)
-		}
-	}
-
-	present := presentLoopWorkflows(dir)
-	if len(present) == 0 {
-		missing = append(missing, wfDir+"/loop-*.yml (no role workflows found)")
-	}
-
-	// Every dispatch/triage role workflow needs its prompt file. (release has none.)
-	for _, role := range present {
-		if role == "release" {
-			continue
-		}
-		prompt := filepath.Join(promptDir, role+".md")
-		if !fileExists(filepath.Join(dir, prompt)) {
-			missing = append(missing, prompt+" (prompt for the loop-"+role+" workflow)")
-		}
-	}
-
-	// The loop is only as good as its gate.
-	if !hasCIWorkflow(dir) {
-		warnings = append(warnings, "no non-loop workflow found in "+wfDir+" — the loop needs a CI gate (build/test/lint) to merge safely")
-	}
-	return warnings, missing
-}
-
-// presentLoopWorkflows returns the role names for which a loop-<role>.yml exists.
-func presentLoopWorkflows(dir string) []string {
-	entries, err := os.ReadDir(filepath.Join(dir, wfDir))
-	if err != nil {
-		return nil
-	}
-	var out []string
-	for _, e := range entries {
-		name := e.Name()
-		if !strings.HasPrefix(name, "loop-") {
-			continue
-		}
-		role := strings.TrimSuffix(strings.TrimSuffix(strings.TrimPrefix(name, "loop-"), ".yml"), ".yaml")
-		out = append(out, role)
-	}
-	sort.Strings(out)
-	return out
-}
-
-func runVerify(c *cli.Context) error {
-	dir := c.String("dir")
-	warnings, missing := verifyState(dir)
-
-	for _, m := range missing {
-		fmt.Printf("  MISSING  %s\n", m)
-	}
-	for _, w := range warnings {
-		fmt.Printf("  WARN     %s\n", w)
-	}
-
-	if len(missing) > 0 {
-		return fmt.Errorf("loop is not fully scaffolded (%d item(s) missing) — run `micro loop init`", len(missing))
-	}
-
-	fmt.Printf("  OK       loop is wired: %s\n", strings.Join(presentLoopWorkflows(dir), ", "))
-	fmt.Println()
-	fmt.Println("Reminders the CLI can't check:")
-	fmt.Println("  • The token secret must be set in the repo (Settings → Secrets).")
-	fmt.Println("  • Branch protection must require the CI checks with 0 approvals,")
-	fmt.Println("    so the builder's auto-merge can land PRs on green CI.")
-	if len(warnings) > 0 {
-		return fmt.Errorf("%d warning(s) — see above", len(warnings))
-	}
-	return nil
-}
-
-func render(tmplName string, cfg config) ([]byte, error) {
-	b, err := templatesFS.ReadFile(tmplName)
-	if err != nil {
-		return nil, err
-	}
-	// Custom delimiters so GitHub Actions' own ${{ }} expressions pass through
-	// untouched — only << >> placeholders are substituted.
-	t, err := template.New(filepath.Base(tmplName)).Delims("<<", ">>").Option("missingkey=error").Parse(string(b))
-	if err != nil {
-		return nil, fmt.Errorf("parse %s: %w", tmplName, err)
-	}
-	var buf bytes.Buffer
-	if err := t.Execute(&buf, cfg); err != nil {
-		return nil, fmt.Errorf("render %s: %w", tmplName, err)
-	}
-	return buf.Bytes(), nil
-}
-
-func writeFile(path string, content []byte, force bool) error {
-	if fileExists(path) && !force {
-		return fmt.Errorf("%s already exists (use --force to overwrite)", path)
-	}
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		return err
-	}
-	return os.WriteFile(path, content, 0o644)
-}
-
-func fileExists(path string) bool {
-	info, err := os.Stat(path)
-	return err == nil && !info.IsDir()
-}
-
-// hasCIWorkflow reports whether .github/workflows holds any workflow that is
-// not one of the loop's own (i.e. a plausible CI gate).
-func hasCIWorkflow(dir string) bool {
-	entries, err := os.ReadDir(filepath.Join(dir, wfDir))
-	if err != nil {
-		return false
-	}
-	for _, e := range entries {
-		if e.IsDir() {
-			continue
-		}
-		name := e.Name()
-		if strings.HasPrefix(name, "loop-") {
-			continue
-		}
-		if strings.HasSuffix(name, ".yml") || strings.HasSuffix(name, ".yaml") {
-			return true
-		}
-	}
-	return false
-}
-
-// detectDefaultBranch best-effort resolves the repo's default branch, falling
-// back to "main".
-func detectDefaultBranch(dir string) string {
-	out, err := exec.Command("git", "-C", dir, "symbolic-ref", "--short", "refs/remotes/origin/HEAD").Output()
-	if err == nil {
-		ref := strings.TrimSpace(string(out))
-		if i := strings.LastIndex(ref, "/"); i >= 0 {
-			ref = ref[i+1:]
-		}
-		if ref != "" {
-			return ref
-		}
-	}
-	return "main"
-}
-
-func printNextSteps(cfg config, roles []string) {
-	fmt.Printf(`
-Loop scaffolded (%s). Next steps (the CLI can't do these for you):
-
-  1. Edit .github/loop/NORTH_STAR.md — the direction the loop aligns to.
-     Seed .github/loop/PRIORITIES.md with a few real items.
-     Tune the per-role instructions in .github/loop/prompts/ if you like.
-
-  2. Add a repo secret named %s: a fine-grained user PAT (contents + pull
-     requests + issues write) for an account the agent (%s) responds to.
-     The workflows no-op until this secret exists.
-
-  3. Ensure a CI workflow named %q exists and that branch protection on %q
-     requires its checks with 0 approving reviews — that green-CI gate is
-     what lets the builder auto-merge safely.
-
-  4. Commit these files, then trigger a run from the Actions tab.
-
-Verify anytime with: micro loop verify
-`, strings.Join(roles, ", "), cfg.TokenSecret, cfg.AgentMention, cfg.CIWorkflow, cfg.DefaultBranch)
-}

cmd/micro/loop/loop_test.go

@@ -1,283 +0,0 @@
-package loop
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-var testCfg = config{
-	DefaultBranch:   "main",
-	AgentMention:    "@codex",
-	TokenSecret:     "LOOP_TOKEN",
-	CIWorkflow:      "CI",
-	CIWorkflowsYAML: `["CI"]`,
-	TagPrefix:       "v",
-	ReleaseCron:     "0 23 * * *",
-}
-
-var testCrons = map[string]string{"planner": "0 * * * *", "builder": "30 * * * *", "coherence": "0 7 * * *"}
-
-// renderable is every template a full scaffold touches, with the per-role config
-// applied the same way scaffold does.
-func renderCases() map[string]config {
-	cases := map[string]config{
-		"templates/loop-triage.yml.tmpl":      testCfg,
-		"templates/loop-release.yml.tmpl":     testCfg,
-		"templates/prompts/triage.md.tmpl":    testCfg,
-		"templates/prompts/planner.md.tmpl":   testCfg,
-		"templates/prompts/builder.md.tmpl":   testCfg,
-		"templates/prompts/coherence.md.tmpl": testCfg,
-		"templates/prompts/security.md.tmpl":  testCfg,
-	}
-	for role, d := range dispatchRoles {
-		rc := testCfg
-		rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = role, d.workflowName, d.issueTitle, d.group, d.defaultCron
-		cases["dispatch:"+role] = rc
-	}
-	return cases
-}
-
-func TestRenderIsPlaceholderFreeAndKeepsGHAExpressions(t *testing.T) {
-	for name, cfg := range renderCases() {
-		tmplName := name
-		if strings.HasPrefix(name, "dispatch:") {
-			tmplName = "templates/dispatch.yml.tmpl"
-		}
-		rendered, err := render(tmplName, cfg)
-		if err != nil {
-			t.Fatalf("render %s: %v", name, err)
-		}
-		s := string(rendered)
-
-		// No unresolved substitution delimiters remain in any template.
-		if strings.Contains(s, "<<") || strings.Contains(s, ">>") {
-			t.Errorf("%s still contains << >> placeholders", name)
-		}
-	}
-}
-
-func TestBaseBranchSubstitutedIntoPrompts(t *testing.T) {
-	// The base branch appears in the PR-opening instructions of these prompts.
-	for _, p := range []string{"planner", "builder", "coherence", "security"} {
-		s := mustRender(t, "templates/prompts/"+p+".md.tmpl", testCfg)
-		if !strings.Contains(s, "--base main") {
-			t.Errorf("%s prompt missing substituted base branch", p)
-		}
-	}
-}
-
-func TestWorkflowTemplatesPreserveGHAAndAreStructural(t *testing.T) {
-	// Only the workflow YAML templates (not the markdown prompts).
-	wf := map[string]config{
-		"templates/loop-triage.yml.tmpl":  testCfg,
-		"templates/loop-release.yml.tmpl": testCfg,
-	}
-	for role, d := range dispatchRoles {
-		rc := testCfg
-		rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = role, d.workflowName, d.issueTitle, d.group, d.defaultCron
-		wf["dispatch:"+role] = rc
-	}
-	for name, cfg := range wf {
-		tmplName := name
-		if strings.HasPrefix(name, "dispatch:") {
-			tmplName = "templates/dispatch.yml.tmpl"
-		}
-		s := mustRender(t, tmplName, cfg)
-		if !strings.Contains(s, "${{ secrets.LOOP_TOKEN") {
-			t.Errorf("%s lost its ${{ secrets.LOOP_TOKEN }} expression", name)
-		}
-		for _, key := range []string{"name:", "on:", "jobs:"} {
-			if !strings.Contains(s, key) {
-				t.Errorf("%s missing top-level %q", name, key)
-			}
-		}
-	}
-}
-
-func TestDispatchWorkflowsStripPromptComments(t *testing.T) {
-	// The posted body must not include the prompt's editorial <!-- --> header;
-	// the workflow strips it. Guard the sed directive in both dispatch paths.
-	rc := testCfg
-	d := dispatchRoles["planner"]
-	rc.Role, rc.WorkflowName, rc.IssueTitle, rc.Group, rc.Cron = "planner", d.workflowName, d.issueTitle, d.group, d.defaultCron
-	for _, tc := range []struct {
-		name, tmpl string
-		cfg        config
-	}{
-		{"dispatch", "templates/dispatch.yml.tmpl", rc},
-		{"triage", "templates/loop-triage.yml.tmpl", testCfg},
-	} {
-		s := mustRender(t, tc.tmpl, tc.cfg)
-		if !strings.Contains(s, `/<!--/,/-->/d`) {
-			t.Errorf("%s workflow does not strip prompt HTML comments before posting", tc.name)
-		}
-	}
-}
-
-func TestPromptsLeaveRuntimeTokensLiteral(t *testing.T) {
-	// __ISSUE__ must survive render (the workflow substitutes it at runtime).
-	for _, p := range []string{"planner", "builder", "coherence", "triage", "security"} {
-		s := mustRender(t, "templates/prompts/"+p+".md.tmpl", testCfg)
-		if !strings.Contains(s, "__ISSUE__") {
-			t.Errorf("%s prompt lost its __ISSUE__ runtime token", p)
-		}
-	}
-	// triage additionally uses __RUNURL__.
-	if s := mustRender(t, "templates/prompts/triage.md.tmpl", testCfg); !strings.Contains(s, "__RUNURL__") {
-		t.Error("triage prompt lost its __RUNURL__ runtime token")
-	}
-}
-
-func TestScaffoldAllRolesWritesEverything(t *testing.T) {
-	dir := t.TempDir()
-	mustWrite(t, filepath.Join(dir, wfDir, "ci.yml"), "name: CI\n")
-
-	roles := []string{"planner", "builder", "triage", "coherence", "security", "release"}
-	if err := scaffold(dir, testCfg, roles, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-
-	wantWorkflows := []string{"loop-planner.yml", "loop-builder.yml", "loop-triage.yml", "loop-coherence.yml", "loop-security.yml", "loop-release.yml"}
-	for _, w := range wantWorkflows {
-		if !fileExists(filepath.Join(dir, wfDir, w)) {
-			t.Errorf("expected %s", w)
-		}
-	}
-	// Dispatch + triage roles have prompts; release does not.
-	for _, p := range []string{"planner.md", "builder.md", "triage.md", "coherence.md", "security.md"} {
-		if !fileExists(filepath.Join(dir, promptDir, p)) {
-			t.Errorf("expected prompt %s", p)
-		}
-	}
-	if fileExists(filepath.Join(dir, promptDir, "release.md")) {
-		t.Error("release should not have a prompt")
-	}
-	if _, missing := verifyState(dir); len(missing) != 0 {
-		t.Errorf("verify reported missing after full scaffold: %v", missing)
-	}
-}
-
-func TestScaffoldDefaultRolesOmitsOptional(t *testing.T) {
-	dir := t.TempDir()
-	if err := scaffold(dir, testCfg, []string{"planner", "builder", "triage"}, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-	if fileExists(filepath.Join(dir, wfDir, "loop-coherence.yml")) {
-		t.Error("coherence should not be written by default")
-	}
-	if fileExists(filepath.Join(dir, wfDir, "loop-release.yml")) {
-		t.Error("release should not be written by default")
-	}
-}
-
-func TestReinitForceKeepsPromptsRefreshesWorkflows(t *testing.T) {
-	dir := t.TempDir()
-	roles := []string{"planner", "builder", "triage"}
-	if err := scaffold(dir, testCfg, roles, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-
-	// Customize a prompt and edit direction/queue, as a real user would.
-	customPrompt := filepath.Join(dir, promptDir, "builder.md")
-	mustWrite(t, customPrompt, "MY CUSTOM BUILDER POLICY")
-	northStar := filepath.Join(dir, loopDir, "NORTH_STAR.md")
-	mustWrite(t, northStar, "MY MISSION")
-
-	// Re-run with --force to refresh workflow mechanics.
-	if err := scaffold(dir, testCfg, roles, testCrons, true); err != nil {
-		t.Fatalf("re-scaffold --force: %v", err)
-	}
-
-	// Policy (prompt, North Star) must survive --force untouched.
-	if b, _ := os.ReadFile(customPrompt); string(b) != "MY CUSTOM BUILDER POLICY" {
-		t.Errorf("--force clobbered a customized prompt: %q", b)
-	}
-	if b, _ := os.ReadFile(northStar); string(b) != "MY MISSION" {
-		t.Errorf("--force clobbered the North Star: %q", b)
-	}
-	// Mechanism (workflow) must be regenerated (present and non-empty).
-	if b, _ := os.ReadFile(filepath.Join(dir, wfDir, "loop-builder.yml")); !strings.Contains(string(b), "Loop: Builder") {
-		t.Error("--force did not refresh the workflow")
-	}
-}
-
-func TestCIWorkflowListRendersAsYAMLArray(t *testing.T) {
-	if got := yamlStringArray([]string{"Harness (E2E)", "Lint", "Run Tests"}); got != `["Harness (E2E)", "Lint", "Run Tests"]` {
-		t.Errorf("yamlStringArray = %q", got)
-	}
-	if got := splitCSV("Harness (E2E), Lint ,Run Tests"); strings.Join(got, "|") != "Harness (E2E)|Lint|Run Tests" {
-		t.Errorf("splitCSV = %v", got)
-	}
-	if got := splitCSV("  "); strings.Join(got, "|") != "CI" {
-		t.Errorf("splitCSV empty should default to CI, got %v", got)
-	}
-	// The triage workflow must embed the array so workflow_run watches all of them.
-	cfg := testCfg
-	cfg.CIWorkflowsYAML = `["Harness (E2E)", "Lint", "Run Tests"]`
-	s := mustRender(t, "templates/loop-triage.yml.tmpl", cfg)
-	if !strings.Contains(s, `workflows: ["Harness (E2E)", "Lint", "Run Tests"]`) {
-		t.Errorf("triage workflow does not watch the CI workflow list:\n%s", s)
-	}
-}
-
-func TestParseRoles(t *testing.T) {
-	if got, err := parseRoles("all"); err != nil || len(got) != len(allRoles) {
-		t.Errorf("all => %v, %v", got, err)
-	}
-	// Canonical order preserved regardless of input order.
-	got, err := parseRoles("release,planner")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Join(got, ",") != "planner,release" {
-		t.Errorf("expected canonical order planner,release; got %v", got)
-	}
-	if _, err := parseRoles("bogus"); err == nil {
-		t.Error("expected error for unknown role")
-	}
-	if _, err := parseRoles(""); err == nil {
-		t.Error("expected error for empty roles")
-	}
-}
-
-func TestVerifyMissingPromptFails(t *testing.T) {
-	dir := t.TempDir()
-	if err := scaffold(dir, testCfg, []string{"planner", "builder", "triage"}, testCrons, false); err != nil {
-		t.Fatalf("scaffold: %v", err)
-	}
-	// Delete a prompt → verify must flag it.
-	if err := os.Remove(filepath.Join(dir, promptDir, "builder.md")); err != nil {
-		t.Fatal(err)
-	}
-	_, missing := verifyState(dir)
-	found := false
-	for _, m := range missing {
-		if strings.Contains(m, "builder.md") {
-			found = true
-		}
-	}
-	if !found {
-		t.Errorf("expected verify to flag the missing builder prompt; got %v", missing)
-	}
-}
-
-func mustRender(t *testing.T, tmplName string, cfg config) string {
-	t.Helper()
-	b, err := render(tmplName, cfg)
-	if err != nil {
-		t.Fatalf("render %s: %v", tmplName, err)
-	}
-	return string(b)
-}
-
-func mustWrite(t *testing.T, path, content string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}

cmd/micro/loop/templates/NORTH_STAR.md

@@ -1,23 +0,0 @@
-# North Star
-
-> **Edit this file.** It is the single source of direction the loop aligns every
-> increment to. The planner ranks work against it; the builder builds toward it.
-> Be concrete — vague direction produces vague increments.
-
-## Mission
-
-<One or two sentences: the problem this repository solves and who it's for.>
-
-## Right now
-
-<The current priority — what "better" means this month. The planner weights the
-queue toward this.>
-
-## Guardrails
-
-- One concern per PR; small and reversible.
-- The gate is green CI, not a human review — keep the test/lint suite strong,
-  because the loop is only as good as its evaluator.
-- **Off-limits without a human** (surface as notes, never auto-merge): breaking
-  public API changes, brand/positioning/marketing copy, new dependencies,
-  architectural rewrites, product-default changes with broad behavioral impact.

cmd/micro/loop/templates/PRIORITIES.md

@@ -1,16 +0,0 @@
-# Priorities
-
-A single ranked queue, highest-value first. Each item links a scoped issue the
-loop can build and CI can verify. The **planner** keeps this current; the
-**builder** takes the top item whose issue is still open.
-
-<!--
-Seed this with a few real items to give the loop a running start, e.g.:
-
-1. Add retry with backoff to the HTTP client — #123
-2. Document the config file format — #124
-3. Fix flaky timeout in the cache tests — #125
-
-The planner will re-rank, drop completed items, and file issues for new gaps.
-Reorder or edit this file at any time to redirect the loop.
--->

cmd/micro/loop/templates/dispatch.yml.tmpl

@@ -1,60 +0,0 @@
-name: "<< .WorkflowName >>"
-
-# Generated by `micro loop init`. A dispatch role of the autonomous loop: on a
-# cadence it opens a fresh tracking issue and posts the instruction in
-# .github/loop/prompts/<< .Role >>.md to the agent (<< .AgentMention >>).
-#
-# The workflow is the MECHANISM; that prompt file is the editable POLICY —
-# change what this role does by editing the prompt, not this YAML. A FRESH
-# issue per run is deliberate: agents derive the PR branch name from the
-# triggering issue, so reusing one tracker collapses every run onto one branch.
-#
-# Gated on << .TokenSecret >>: the agent ignores @mentions from the
-# github-actions bot, so dispatch posts as a real user (a PAT). No token → no-op.
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "<< .Cron >>"
-
-permissions:
-  issues: write
-
-concurrency:
-  group: << .Group >>
-  cancel-in-progress: false
-
-jobs:
-  dispatch:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch << .Role >>
-        env:
-          GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
-          HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
-          REPO: ${{ github.repository }}
-          RUN_NUMBER: ${{ github.run_number }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "<< .TokenSecret >> is not set — skipping (the agent ignores bot @mentions)."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/<< .Role >>.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "<< .IssueTitle >> #$RUN_NUMBER" \
-            --body "Autonomous << .Role >> pass. Direction: .github/loop/NORTH_STAR.md; queue: .github/loop/PRIORITIES.md.")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching << .Role >>."
-          # The prompt file is the policy; strip its editorial <!-- --> header and
-          # substitute the tracking issue number (__ISSUE__) at runtime.
-          {
-            echo "<< .AgentMention >>"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

cmd/micro/loop/templates/loop-release.yml.tmpl

@@ -1,97 +0,0 @@
-name: "Loop: Release"
-
-# Generated by `micro loop init`. Cuts the next tag when the default branch has
-# new commits since the latest one, and pushes it with a PAT (<< .TokenSecret >>)
-# so any tag-triggered release workflow fires. The bump reflects what shipped,
-# read from the CHANGELOG [Unreleased] section: new features (Added/Changed) cut
-# a MINOR; fixes/docs only cut a PATCH; breaking changes are skipped so a MAJOR
-# stays a human decision.
-#
-# The tag MUST be pushed with a PAT, not the default GITHUB_TOKEN: a tag pushed
-# by GITHUB_TOKEN does not trigger other workflows (Actions blocks that recursion).
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: "<< .ReleaseCron >>"
-
-permissions:
-  contents: read
-
-concurrency:
-  group: loop-release
-  cancel-in-progress: false
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # need full history + all tags
-          # Do NOT persist the default GITHUB_TOKEN as a git credential: it would
-          # be sent on the PAT push below and override it, so the tag push would
-          # authenticate as github-actions[bot] and 403. Letting the PAT in the
-          # push URL be the only credential is the whole point.
-          persist-credentials: false
-      - name: Cut the next patch tag if there are new commits
-        env:
-          RELEASE_TOKEN: ${{ secrets.<< .TokenSecret >> }}
-          REPO: ${{ github.repository }}
-        run: |
-          if [ -z "$RELEASE_TOKEN" ]; then
-            echo "<< .TokenSecret >> is not set — skipping."
-            exit 0
-          fi
-          git fetch --tags --force
-
-          LATEST=$(git tag --list '<< .TagPrefix >>*.*.*' --sort=-v:refname | head -1)
-          if [ -z "$LATEST" ]; then
-            echo "no << .TagPrefix >>MAJOR.MINOR.PATCH tag found — aborting so nothing weird gets tagged."
-            exit 1
-          fi
-          echo "latest tag: $LATEST"
-
-          COUNT=$(git rev-list --count "$LATEST"..HEAD)
-          echo "commits since $LATEST: $COUNT"
-          if [ "$COUNT" -eq 0 ]; then
-            echo "no new commits since $LATEST — no release."
-            exit 0
-          fi
-
-          ver="${LATEST#<< .TagPrefix >>}"
-          major="${ver%%.*}"
-          rest="${ver#*.}"
-          minor="${rest%%.*}"
-          patch="${rest#*.}"
-          case "$major.$minor.$patch" in
-            [0-9]*.[0-9]*.[0-9]*) ;;
-            *) echo "unexpected tag shape: $LATEST" ; exit 1 ;;
-          esac
-
-          # Choose the bump from what actually shipped, read from the CHANGELOG
-          # [Unreleased] section (kept current by the coherence role):
-          #   new features (### Added / ### Changed) -> MINOR
-          #   fixes/docs only                        -> PATCH
-          #   breaking (### Removed / "(breaking)")  -> skip; a major is a human call
-          UNRELEASED=""
-          if [ -f CHANGELOG.md ]; then
-            UNRELEASED=$(awk '/^## \[Unreleased\]/{f=1; next} /^## \[/{f=0} f' CHANGELOG.md)
-          fi
-          if printf '%s\n' "$UNRELEASED" | grep -qiE '^### Removed|^### Changed \(breaking\)|BREAKING'; then
-            echo "CHANGELOG [Unreleased] contains breaking changes — a major release is a human decision. Skipping."
-            exit 0
-          elif printf '%s\n' "$UNRELEASED" | grep -qE '^### (Added|Changed)'; then
-            NEXT="<< .TagPrefix >>${major}.$((minor + 1)).0"
-            KIND="minor (new features)"
-          else
-            NEXT="<< .TagPrefix >>${major}.${minor}.$((patch + 1))"
-            KIND="patch (fixes/docs only)"
-          fi
-          echo "cutting: $NEXT — $KIND ($COUNT commits since $LATEST)"
-
-          git config user.name "loop release bot"
-          git config user.email "noreply@users.noreply.github.com"
-          git tag -a "$NEXT" -m "Release $NEXT — automated $KIND ($COUNT commits since $LATEST)"
-          git push "https://x-access-token:${RELEASE_TOKEN}@github.com/${REPO}.git" "$NEXT"
-          echo "Pushed $NEXT."

cmd/micro/loop/templates/loop-triage.yml.tmpl

@@ -1,57 +0,0 @@
-name: "Loop: Triage"
-
-# Generated by `micro loop init`. The feedback path of the evaluator: when a CI
-# workflow (<< .CIWorkflow >>) fails on a non-PR run, dispatch the agent
-# (<< .AgentMention >>) with the instruction in .github/loop/prompts/triage.md
-# to root-cause the failure and file scoped fix issues back into the queue — so
-# failures become fixes with no human in the middle. Gated on << .TokenSecret >>.
-
-on:
-  workflow_run:
-    workflows: << .CIWorkflowsYAML >>
-    types: [completed]
-
-permissions:
-  issues: write
-
-concurrency:
-  group: loop-triage
-  cancel-in-progress: false
-
-jobs:
-  triage:
-    # Only real failures on branch pushes/schedules — not PR-run failures, which
-    # the PR author already sees.
-    if: ${{ github.event.workflow_run.conclusion == 'failure' && github.event.workflow_run.event != 'pull_request' }}
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4 # needed to read the prompt file
-      - name: Dispatch triage
-        env:
-          GH_TOKEN: ${{ secrets.<< .TokenSecret >> || github.token }}
-          HAS_TOKEN: ${{ secrets.<< .TokenSecret >> != '' }}
-          REPO: ${{ github.repository }}
-          RUN_ID: ${{ github.event.workflow_run.id }}
-          RUN_URL: ${{ github.event.workflow_run.html_url }}
-          WORKFLOW_NAME: ${{ github.event.workflow_run.name }}
-        run: |
-          if [ "$HAS_TOKEN" != "true" ]; then
-            echo "<< .TokenSecret >> is not set — skipping."
-            exit 0
-          fi
-          PROMPT=".github/loop/prompts/triage.md"
-          if [ ! -f "$PROMPT" ]; then
-            echo "missing $PROMPT — run 'micro loop init'." >&2
-            exit 1
-          fi
-          ISSUE_URL=$(gh issue create --repo "$REPO" \
-            --title "Loop: triage failed run $RUN_ID ($WORKFLOW_NAME)" \
-            --body "The '$WORKFLOW_NAME' workflow failed on a non-PR run: $RUN_URL")
-          ISSUE_NUM="${ISSUE_URL##*/}"
-          echo "Opened issue #$ISSUE_NUM — dispatching triage."
-          {
-            echo "<< .AgentMention >>"
-            echo
-            sed -e '/<!--/,/-->/d' -e "s/__ISSUE__/$ISSUE_NUM/g" -e "s#__RUNURL__#$RUN_URL#g" "$PROMPT"
-          } > "$RUNNER_TEMP/loop-body.md"
-          gh issue comment "$ISSUE_NUM" --repo "$REPO" --body-file "$RUNNER_TEMP/loop-body.md"

cmd/micro/loop/templates/prompts/builder.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The BUILDER prompt — the editable policy for the builder role. The workflow
-prepends the agent @mention and substitutes __ISSUE__ before posting. Keep
-__ISSUE__ literal.
--->
-Build one increment for this repository, aligned to `.github/loop/NORTH_STAR.md`.
-
-PICK THE WORK: take the highest-ranked item in `.github/loop/PRIORITIES.md` whose linked issue is still OPEN — that is your task, and its issue is the one you close. If the queue is empty or every item's issue is closed, pick the single highest-value improvement yourself.
-
-Implement it, then VERIFY the project builds, tests, and lints (use the commands documented in the README or the CI workflow).
-
-Open the PR YOURSELF from the shell — do NOT use a make_pr tool (it may be a no-op stub): `git switch -c loop/increment-__ISSUE__`, `git push -u origin loop/increment-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<body; include 'Closes #<the item's issue>' so it leaves the queue, and 'Closes #__ISSUE__' for this run's tracker>"`, then `gh pr merge --squash --auto --delete-branch` so it lands once CI is green.
-
-One concern per PR. Stay out of breaking public API changes and brand/positioning copy — surface those as notes for a human instead.

cmd/micro/loop/templates/prompts/coherence.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The COHERENCE (DevRel) prompt — the editable policy for the coherence role. The
-workflow prepends the agent @mention and substitutes __ISSUE__ before posting.
-Keep __ISSUE__ literal.
--->
-Act as DevRel for this repository — keep the public story coherent and honest.
-
-Audit the public surface — `README`, docs, and any website/blog — for coherence with `.github/loop/NORTH_STAR.md`: places that contradict each other, are stale, or describe behavior that has since changed (cross-check against the code and recently merged PRs). If the repo keeps a `CHANGELOG.md`, reconcile its `[Unreleased]` section against what actually merged.
-
-SAFE factual-alignment and crispness fixes (and the CHANGELOG upkeep): open ONE PR and auto-merge it — `git switch -c loop/coherence-__ISSUE__`, `git push -u origin loop/coherence-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`.
-
-Brand / positioning / marketing copy and any opinion blog posts are NOT auto-merge material — the public voice stays with a human. Describe them in a comment on this issue, or open a PR WITHOUT enabling auto-merge, and leave it for review.
-
-Post a short findings report as a comment on this issue (#__ISSUE__): what's aligned, what drifted, what you fixed. Open PRs yourself from the shell with `gh`; do not use a make_pr tool.

cmd/micro/loop/templates/prompts/planner.md.tmpl

@@ -1,15 +0,0 @@
-<!--
-The PLANNER prompt. This file is the editable policy for the planner role —
-change what the planner does by editing this text. The workflow prepends the
-agent @mention and substitutes __ISSUE__ (this run's tracking issue) before
-posting it. Keep __ISSUE__ literal.
--->
-Act as the planner for this repository.
-
-(1) Read `.github/loop/NORTH_STAR.md` for direction, then scan recently merged PRs and open issues so the queue reflects reality — drop done items, don't re-queue work already in flight.
-
-(2) Maintain a SINGLE ranked queue in `.github/loop/PRIORITIES.md`, highest-value first, each item linking a scoped, CI-verifiable issue (#N). For any prioritized gap that has no issue, file one: `gh issue create --title "<scoped task>" --body "<goal, scope, acceptance criteria>"`.
-
-(3) If the ranking actually changed, open ONE PR for `PRIORITIES.md`: `git switch -c loop/planner-__ISSUE__`, `git push -u origin loop/planner-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<summary, Closes #__ISSUE__>"`, then `gh pr merge --squash --auto --delete-branch`. If the queue is already accurate, just close this issue (`gh issue close __ISSUE__`).
-
-Do NOT make breaking or architectural changes yourself — surface those as notes for a human. Open the PR yourself from the shell with `gh`; do not use a make_pr tool (it may be a no-op stub).

cmd/micro/loop/templates/prompts/security.md.tmpl

@@ -1,22 +0,0 @@
-<!--
-The SECURITY prompt — the editable policy for the security role. The workflow
-prepends the agent @mention and substitutes __ISSUE__ before posting. Keep
-__ISSUE__ literal.
-
-Security is deliberately more conservative than the other roles: it does NOT
-auto-merge fixes, and it does NOT publish exploit details in public issues.
--->
-Act as the security reviewer for this repository. Audit for real, exploitable vulnerabilities — do not pad the report with theoretical or low-value lint-style noise.
-
-WHAT TO LOOK FOR: injection (SQL/command/template), authentication and authorization bypass, credential/secret/token exposure (in code, logs, or error messages), SSRF and unsafe outbound requests (especially user- or config-controlled URLs), path traversal, unsafe deserialization, missing or incorrect input validation on trust boundaries (HTTP handlers, RPC endpoints, message consumers), insecure defaults (TLS, auth, permissions), unsafe use of `crypto`/randomness, and known-vulnerable dependencies (run `govulncheck ./...` if available, or inspect `go.mod`).
-
-DEDUPE against open issues before filing anything.
-
-HOW TO REPORT — this matters:
-- **Known/public dependency CVEs** (already disclosed): file an issue labeled `security` referencing the CVE and the affected module, and you MAY open a PR that bumps the dependency to the patched version. Do **NOT** enable auto-merge — leave it for human review.
-- **Novel, exploitable vulnerabilities in this codebase** (not yet public): do **NOT** post a working exploit, proof-of-concept, or step-by-step reproduction in a public issue — that is irresponsible disclosure. File a CONCISE issue labeled `security` and `needs-human` that names the vulnerability *class*, the *location* (file/function), and the *impact*, with only enough detail for a maintainer to find it — and note it should be handled via the repository's private vulnerability reporting if the repo is public. Do NOT open a public fix PR that reveals the vulnerability; leave the fix to a human.
-- **Low-risk hardening** (defense-in-depth, missing validation with no proven exploit): a normal `security` issue is fine.
-
-NEVER auto-merge a security change. Never weaken a control to make a test pass. Anything requiring an architectural or breaking change: label it `needs-human` and describe the tradeoff.
-
-Post a summary as a comment on this issue (#__ISSUE__) — how many findings by severity, what you filed, and what needs a human — then close it (`gh issue close __ISSUE__`). If you open a dependency-bump PR, do it yourself from the shell: `git switch -c loop/security-__ISSUE__`, `git push -u origin loop/security-__ISSUE__`, `gh pr create --base << .DefaultBranch >> --title "<title>" --body "<summary, Closes #__ISSUE__>"` — then STOP; do NOT run `gh pr merge --auto`. Do not use a make_pr tool.

cmd/micro/loop/templates/prompts/triage.md.tmpl

@@ -1,14 +0,0 @@
-<!--
-The TRIAGE prompt — the editable policy for the triage role. The workflow
-prepends the agent @mention and substitutes __ISSUE__ (this tracking issue) and
-__RUNURL__ (the failed CI run) before posting. Keep both literal.
--->
-Triage the failed CI run at __RUNURL__.
-
-Read the logs and root-cause each distinct failure. DEDUPE against open issues — if a failure matches an existing issue, comment "recurred" there instead of filing a duplicate.
-
-For each genuine, self-contained defect, file a scoped issue (`gh issue create --title "<scoped fix>" --body "<root cause, where, acceptance criteria>"`) so the planner/builder can pick it up and the next CI run verifies it.
-
-IGNORE transient flakes — network blips, provider outages, timeouts with no code cause. Anything needing a breaking or architectural change: label it `needs-human` and describe it, rather than auto-filing it as a routine fix.
-
-Close this issue (`gh issue close __ISSUE__`) when triage is done.

cmd/micro/main.go

@@ -12,8 +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/loop"
 	_ "go-micro.dev/v6/cmd/micro/mcp"
 	_ "go-micro.dev/v6/cmd/micro/resource"
 	_ "go-micro.dev/v6/cmd/micro/run"

cmd/micro/run/run.go

@@ -498,13 +498,10 @@ func printBanner(services []*serviceProcess, gw *server.Gateway, watching bool,
 		fmt.Printf("  Dashboard   \033[36mhttp://localhost%s\033[0m\n", gw.Addr())
 		fmt.Printf("  API         \033[36mhttp://localhost%s/api/{service}/{method}\033[0m\n", gw.Addr())
 		fmt.Printf("  Agent       \033[36mhttp://localhost%s/agent\033[0m\n", gw.Addr())
-		// MCP tools are served on the gateway by default — every endpoint is an
-		// AI-callable tool, so surface it rather than hiding it behind a flag.
-		fmt.Printf("  MCP Tools   \033[36mhttp://localhost%s/mcp/tools\033[0m\n", gw.Addr())
 		fmt.Printf("  Health      \033[36mhttp://localhost%s/health\033[0m\n", gw.Addr())
 		if mcpAddr != "" {
-			// Optional standalone MCP protocol server (e.g. for MCP clients).
-			fmt.Printf("  MCP Server  \033[36mhttp://localhost%s\033[0m (full MCP protocol)\n", mcpAddr)
+			fmt.Printf("  MCP         \033[36mhttp://localhost%s\033[0m\n", mcpAddr)
+			fmt.Printf("  MCP Tools   \033[36mhttp://localhost%s/mcp/tools\033[0m\n", mcpAddr)
 			fmt.Printf("  WebSocket   \033[36mws://localhost%s/mcp/ws\033[0m\n", mcpAddr)
 		}
 	}

cmd/micro/zero_to_hero_cli_test.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"bytes"
-	"strings"
 	"testing"
 
 	microcmd "go-micro.dev/v6/cmd"
@@ -21,7 +19,7 @@ func TestZeroToHeroCLIBoundaries(t *testing.T) {
 		}
 	}
 
-	for _, want := range []string{"run", "chat", "flow", "inspect", "deploy", "zero-to-hero"} {
+	for _, want := range []string{"run", "chat", "flow"} {
 		if !commands[want] {
 			t.Fatalf("missing %q command", want)
 		}
@@ -29,50 +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")
-	}
-
-	var hasDeployDryRun bool
-	for _, command := range microcmd.DefaultCmd.App().Commands {
-		if command.Name != "deploy" {
-			continue
-		}
-		for _, flag := range command.Flags {
-			for _, name := range flag.Names() {
-				if name == "dry-run" {
-					hasDeployDryRun = true
-				}
-			}
-		}
-	}
-	if !hasDeployDryRun {
-		t.Fatal("missing deploy boundary: deploy --dry-run")
-	}
-}
-
-func TestZeroToHeroCommandPrintsMaintainedNoSecretPath(t *testing.T) {
-	app := microcmd.DefaultCmd.App()
-	var out bytes.Buffer
-	oldWriter := app.Writer
-	app.Writer = &out
-	t.Cleanup(func() { app.Writer = oldWriter })
-
-	if err := app.Run([]string{"micro", "zero-to-hero"}); err != nil {
-		t.Fatalf("micro zero-to-hero failed: %v", err)
-	}
-
-	got := out.String()
-	for _, want := range []string{
-		"0→hero no-secret lifecycle demo",
-		"./internal/harness/zero-to-hero-ci/run.sh",
-		"go run ./examples/first-agent",
-		"go run ./examples/support",
-		"make harness",
-		"services → agents → workflows",
-	} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("micro zero-to-hero output missing %q:\n%s", want, got)
-		}
-	}
 }