v0.88.0 — Agents, MCP, and registries from one Go design

v0.88.0 — Agents, MCP, and registries from one Go design

Goa-AI generates typed agent tools, MCP clients and servers, and distributed tool
contracts from Goa designs. This release replaces its MCP implementation with
MCP 2026-07-28, adds authorization and extension capabilities, and
carries typed additional input and durable jobs through local and registry tools.
It also improves agent execution, tool search, and generated JSON contracts.

This is a breaking feature release after v0.87.1. Upgrade generated code,
runtime workers, providers, consumers, and application storage implementations
together. Generated stdio servers remain deferred; stdio consumers are supported.

Build MCP services with ordinary Goa methods

MCP servers now use stateless request metadata and server/discover. The old
initialization, protocol-session state, revision override, and session repair
APIs are removed. Generated adapters invoke configured Goa endpoints, retaining
security callbacks, interceptors, middleware, mapped URL inputs, inherited types,
and result views. Ordinary HTTP and gRPC methods can share the service.

The generated surface includes:

• Tools with structured results and ordered text, image, audio, resource links,
  and embedded resources. ToolContent selects presentation content;
  ToolMetadata keeps typed completed-result data private to hosts and apps.
• Fixed and parameterized text/binary resources, typed prompts, and prompt or
  resource-template argument completion.
• Authenticated, paginated tool, prompt, resource, and resource-template catalogs,
  plus exact URI reads through ResourceReader.
• Request-scoped progress and acknowledged subscriptions for catalog changes,
  resource updates, and full Task state through one authored service stream.

For example, marking a method with Tool("lookup", "Look up a product")
generates its MCP input and output contracts from that method's Goa types;
you implement the original service method rather than a second MCP handler.

Continue unfinished work without recreating it

InputExchange binds a native continuation field and a complete/input-required
result union. Generated code derives form questions and answer codecs from Goa
types. Form input and URL consent stay outside model arguments. Tools, resources,
and prompts call the original authenticated endpoint on each round.

TaskExchange exposes existing durable job methods for creation, observation,
answers, and cancellation. The service durably accepts work before returning a
handle. The runtime retains that handle across host answers and worker replacement;
observation never repeats the creating tool. Cancellation remains owned by durable
execution until accepted work settles.

Native BindTo executors and registry providers share these generated operations.
Registry wire protocol 13 carries operation identity and typed continuation
separately from model arguments. Repeated delivery returns the saved operation
outcome; changed data under the same operation identity is rejected.

A runtime store must atomically admit one successor for a suspended run and retain
unfinished work during purge checks. Temporal supplies restart-safe execution with
an application-owned durable store; the in-memory engine supplies process-lifetime
guarantees.

Authorize MCP clients and servers

Built-in clients support browser authorization with PKCE, machine credentials,
signed client authentication, and enterprise identity exchange. Registration fixes
the trusted client and issuer; preregistration and HTTPS client metadata replace
deprecated dynamic registration. Hosts own consent and private credential storage.

Protected servers verify configured signed-token keys or use authenticated token
introspection. Invalid credentials return 401, insufficient scopes return 403,
and verification infrastructure failures return 503. Domain failures after
execution do not become authorization challenges.

HTTP retries default to one attempt. Explicit endpoint trust and a read-only or
idempotent tool declaration permit bounded retries after interrupted event-stream
delivery. Unknown effects are never treated as permission to repeat a tool.
The service still owns side-effect idempotency.

Add Apps and Skills

ToolUI associates a tool with a same-server HTML resource; ToolVisibility
separates model and app callers. The maintained browser host composes the official
Apps SDK with generated endpoints, catalog permissions, isolated frames, and
origin-checked delivery. Browser dependencies remain in the example.

SkillCatalog, SkillLookup, and optional directory methods publish instructions
and supporting files through ordinary resource reads. VerifySkillFile checks
manifest membership, exact bytes, digest, and complete YAML frontmatter before
instructions are accepted. The reference host loads lazily, separates origins,
and binds local-execution approval to the complete retained manifest. Listing a
Skill neither activates it nor grants tool permissions.

Improve generated contracts and agent execution

• JSON codecs and schemas preserve native tagged, flat, and untagged unions,
  exact numbers, selected views, and field descriptions. Shared unions use Goa's
  renderer, including Kind, typed accessors, and template-safe Value().
• Text-only runs exclude interactive rendering, confirmation, and host input.
  UIResultReminder limits guidance that assumes a rendered result.
• Typed tool output can use explicit forced or automatic tool choice with bounded
  model correction. Direct completions retain their separate output contract.
• Saved pagination survives turns and checkpoints. Provider failures retain
  their typed cause through planner activities, helper calls share the parent's
  recovery allowance, and live thinking text emits each new fragment once.
• Named Deferred selections keep frequently used compiled tools immediately
  available. Registry definition validation reuses exact saved bytes; generated
  injection metadata no longer requires an agent-engine import.
• Registry providers renew exact leases, and explicit service replacement waits
  for old providers to finish. Sealing honors cancellation while waiting for
  registration or another sealer. Unsupported forced choices on Bedrock Fable 5.1
  fail locally before inference.

The root and four maintained nested modules require Go 1.27.0 or newer and pin
merged Goa 9fd65ad2c943. Model SDKs, Temporal, transport, storage, observability,
and example dependencies are updated in their owning modules.

Required upgrade actions

1. Update and regenerate. Install Go 1.27+, update Goa-AI to v0.88.0, and run
   generation with the application's module-selected Goa version. Rebuild all
   servers, clients, providers, agent executors, and stored-value codecs.
2. Replace removed APIs. Remove protocol-version and session initialization
   options, the function-only CallerFunc, old content types in runtime/mcp,
   MountWithOrigins, and bare-service MCP adapter constructors. Use configured
   endpoints, the shared runtime/content contract, and constructor-supplied
   browser origins. Follow the MCP source upgrade.
3. Coordinate protocol peers. Deploy MCP clients and servers with the current
   revision, and registry replicas, providers, and consumers with wire version 13.
   Older revisions are not interchangeable. Compare regenerated declarations and
   fingerprints; do not assume admission tokens survive a wire-version change.
4. Prepare stored execution. Current suspension checkpoints use
   goa-ai.run-suspension.v13; earlier checkpoints are rejected. Complete or
   otherwise resolve incompatible accepted work on its owning worker version
   before replacement. Upgrade runtime stores for successor admission, retained
   history, saved pagination, start/result ownership, and durable cancellation.
   Follow the stored-work cutover,
   runtime store contract, and
   saved-result requirements.
5. Preserve registry history. Installations with the older combined catalog
   layout need an installation-owned, verified offline conversion with all old
   writers stopped. No general-purpose converter is shipped. Preserve exact
   declarations, retired tokens, and execution history; settle old calls and
   re-admit current declarations for the new wire contract. See the
   registry storage upgrade.
6. Verify before resuming admissions. Check authentication, each required
   catalog, representative tool calls, host input, Task completion/cancellation,
   and storage recovery in the target installation. Hosts persisting OAuth grants
   must implement the private AuthorizationStore contract; the supplied memory
   store does not survive restarts.

Mixed old and new generated contracts, registry wire versions, and executable
checkpoints are unsupported. This framework release does not perform application
database migrations or production deployments. A source rollback alone cannot
read newly accepted work; recovery must retain compatible workers and stored data.
Before new writes, an untouched backup can restore the old installation with all
writers stopped. After new writes, use a planned recovery that preserves them.

Verification and references

The release documentation and regenerated fixtures passed all seven jobs at
fcbb4458. The final release CI
includes build/lint, unit tests, HTTP integration, browser Apps, and every MCP
generator shard. Its longest job took 6 minutes 48 seconds. The repository-wide
documentation audit verified local links and anchors, all 118 external
destinations, executable README and DSL designs, and the runnable quickstart.

The merged MCP implementation passed all seven jobs at its final implementation
commit: build and lint, unit tests, HTTP integration, browser Apps, and four
MCP generator shards. The recorded CI run
includes every generated check; the longest job took 6 minutes 42 seconds.
Independent protocol and authorization checks have explicit fixture limitations;
this release makes no claim of universal conformance or a live storage cutover.

• Documentation and release review
• MCP upgrade and review
• MCP integration guide
• Authorization and client contracts
• Apps reference host and Skills guide
• Registry and deferred search
• Independent verification and limitations