[nissa-seru]

TL;DR: fetch_reference now refuses a reference from an MCPL server the host doesn't connect to over a network, such as a stdio server, for that reason, naming the server, where it said "unknown server". save_recent_image now gives the reason a fetch_reference call naming no max_bytes would be refused with before dialing, and points at fetch_reference only where that fetch would go ahead. The eager fetch no longer gives one of its slots to a reference the fetch would refuse before dialing.

Problem

On main d1b9d35c:

• A server the host doesn't reach over a network, as a stdio server is not, delivers references that are bound to it, and their stubs offer fetch_reference. The framework's resolver gives the fetcher nothing for a server whose config has no url (src/framework.ts:4693), so the fetcher refuses as it does for a server the host doesn't know: "unknown server: " (src/mcpl/reference-fetcher.ts:148).
• A server the host doesn't dial at its url: the host connects over WebSocket or spawns a server as isWebSocketTransport decides (src/mcpl/transport.ts:548, which openTransport asks at :592), and it spawns one whose config holds both a command and a url and names no transport. Its WebSocket transport dials only a ws:// or wss:// url, as buildWebSocketUrl checks (:520), and the ws library it dials with refuses one with a fragment. The resolver gives the fetcher a server's url whatever its transport and scheme, so a reference on that url's origin is fetched, with any token the config holds, though the host never connects there for that server.
• save_recent_image's refusal of a reference asks only what the record shows (unfetchableReason, src/framework.ts:23026): its binding and its expiry. Where the fetch would refuse for anything else, such as a server with no address or one the host doesn't know, a uri off its servers' origins, a spent budget or a claim over the ceiling, it says "Fetch it with fetch_reference and save the materialized file instead." (:23036), and the call it suggests is refused.
• The eager check (isEagerEligible, src/mcpl/reference-fetcher.ts:130) makes the fetch's checks of the server and the expiry, but not of the budget or the ceiling, so a reference the fetch refuses for one of those can still take one of a result's eight eager slots (src/framework.ts:4747).

A probe on main shows the first, second and fourth. Through the framework's own resolver, fetch_reference answered "unknown server: stdio-srv" for a stdio server's reference, with nothing dialed. It fetched a reference on a loopback http:// origin for a server with a command and that url, for a server whose transport is websocket and whose url is that http:// one, and for a WebSocket server whose ws:// url on that origin has a fragment. The probe's ws won't dial that url, and its constructor throws "The URL contains a fragment identifier". The eager check called two references eligible, a small claim from a server whose budget was spent and a 512 MiB claim from a server whose eager limit is 4 GiB, and the fetch then refused both, one for the budget and one for the ceiling.

Changes

• The resolver answers three ways: a server's address and credential; 'no-address' for a server the host doesn't connect to over a network; or nothing for a server the host doesn't know, as before. It decides as the connection does: through isWebSocketTransport, so a server the host spawns has no address whatever else its config holds, and then through buildWebSocketUrl's own check, called with no token, so a WebSocket server whose url the transport won't dial has none either. That check now also refuses a url with a fragment, as the ws library does when asked to dial it, so the transport fails such a server's connect with its own error, naming the fragment. The binding's doc now says the framework gives only a ws:// or wss:// url.
• The refusal names the server: noAddressReason(serverId) in src/mcpl/references.ts, beside UNBOUND_REASON, gives "no address: this host doesn't connect to server over a network, so there's nowhere to fetch it from". Like "unknown server: ", it describes a server, so fetch_reference gives it without the "reference " it puts before the reference's own reasons ("reference unbound: …", "reference expired: …"). When several servers delivered a reference, the fetcher still dials through the first on the uri's origin, passing over one with no address, and when none is, it still gives the first server's refusal.
• One check before dialing: every check the fetcher makes before it dials now sits in one private function, in the fetch's order: the server (none, unknown, no address, off the uri's origin), the expiry, a spent budget, then a claim over the ceiling, which is refused for the budget where it's also over what's left of it. Three things ask it:
  • the fetch;
  • the fetcher's new refusal(record), which answers what a fetch_reference call naming no max_bytes would be refused with before dialing. It answers nothing where the fetch would serve a saved copy, join a fetch of the record already under way, or dial, the same three steps fetch() takes;
  • the eager check, which then adds only the dialed server's eager limit, so a reference the fetch would refuse before dialing takes no eager slot. For a reference whose fetch is already under way, it lets the eager fetch join that fetch, as fetch() does, within its server's eager limit. The expiry, the budget and the ceiling, which that fetch passed when it began, don't enter. A result that itself calls a reference expired still gives it no eager slot, as on main.
• save_recent_image asks refusal(record) and gives its reason in the sentence it already gives an unbound or expired reference's: "… Nothing written. It can't be fetched either — no address: this host doesn't connect to server … over a network, …", or "— third-party origin (…); not fetched by this host.", or "— per-server fetch budget exhausted (…); the budget doesn't renew on its own, …", and so on. It points at fetch_reference only where the fetch would serve, join or dial.
• The stub is unchanged: it still offers the fetch for every bound reference. It's built where only the record is known, and which servers the host can dial is the framework's to know. unfetchableReason, which gives the stub its reason from the record alone, now serves the stub only. The comments on convertBlock and on executeMcplToolCall's registration now say a reference they register can be fetched through its server's address, where it has one, and so does the unreleased changelog fragment for that registration.
• Changelog: a fragment says what changes for fetch_reference, save_recent_image and the eager fetch.

What callers will notice

• Agents: a reference from a stdio server, or from a server spawned from a command whose config also holds a url, is refused by fetch_reference with "no address: this host doesn't connect to server over a network, so there's nowhere to fetch it from", with nothing dialed, where the first was refused as "unknown server: " and the second fetched from that url's origin. A reference several servers delivered follows the rule above. save_recent_image says why a reference can't be fetched wherever a fetch_reference call naming no max_bytes would be refused before dialing, instead of pointing at fetch_reference.
• Operators: a server spawned from a command whose config also holds a url, or a WebSocket server whose url isn't ws:// or wss:// or has a fragment, no longer has its references on that url's origin fetched, with any token its config holds. A WebSocket server whose url has a fragment fails to connect with MCPL server "<id>": websocket url must not have a fragment, got "#…", where it failed with the ws library's The URL contains a fragment identifier. The eager fetch no longer logs a failure for a reference it now leaves out, such as one from a server whose budget is spent.
• Exports: references.ts and reference-fetcher.ts aren't exported from the package's entry point. AgentFramework is, and none of its public methods' signatures change, so no public export changes.

Tests

On Linux, with Node 24.22.0 and 20.20.2, each run from a clean build after npm install, as CI installs:

• At this head, d206b05a: tsc --noEmit is clean. The seven test files on references (mcpl-reference-binding, mcpl-push-convert, mcpl-reference-fetcher, puppet-tool-call, tool-result-history, mcpl-reference-fields and save-recent-image) and mcpl-ws-transport, run without --test-force-exit, pass 174 of 174 on each runtime. CI runs the whole suite.

• New, in test/mcpl-reference-fetcher.test.ts:

  • a reference from a server with no address is refused in the phrase naming it, with nothing dialed and no eager slot though its claim is small, and is fetched once a server on the uri's origin delivers it too;
  • a server with no address ahead of one off the origin is the refusal, and the other way round the origin check's is;
  • refusal() answers, case by case, what the fetch then answers, with nothing dialed: no server, an unknown server, no address, an off-origin uri, an expiry, a spent budget, a claim over the ceiling, and a claim over both the ceiling and what's left of the budget, the last two from a server whose eager limit is past both. None of them gets an eager slot. It answers nothing for a saved copy, or for a reference it would dial, which gets an eager slot, though a saved copy of one it would dial doesn't;
  • a reference with two faults is refused for the first the fetch checks: no address before an expiry, an expiry before a spent budget, and a spent budget before a claim over the ceiling;
  • refusal() answers nothing while a fetch of the record is under way, though the record's claims change meanwhile;
  • a reference whose fetch is under way stays eager-eligible once that fetch has spent its server's budget, its save held open, and once its record claims an expiry, while another reference from that server is refused for the budget. The framework's eager pass for a later tool result carrying the reference then joins that fetch: it gets the fetch's own promise, the reference is requested once, and no eager failure is logged. Once the save lands, the saved copy takes no eager slot.

• New, in test/mcpl-ws-transport.test.ts: buildWebSocketUrl refuses a url with a fragment, naming it, and accepts an empty one, and the ws library's own constructor refuses the same url.

• New, in test/save-recent-image.test.ts: references from a server with no address, from one off its origin, from an unknown server, with a claim over the ceiling and from a server whose budget is spent each refuse with the fetcher's reason, and none points at fetch_reference.

• Changed: test/mcpl-reference-binding.test.ts's fetch through the framework's own fetcher now dials a WebSocket server at a ws:// url, as the transport would, and expects the no-address refusal for its stdio server and for a server spawned from a command whose config also holds a url on the reference's origin. It adds a server the host doesn't know, refused as unknown, and three that set transport: one set to websocket whose config also holds a command, which is fetched through; one set to stdio whose config holds only a url, and one set to websocket whose url is http://, each refused as no address with nothing dialed. A WebSocket server whose ws:// url, on the reference's origin, has a fragment is refused as no address too, with nothing dialed. The fetcher test of an unknown server names it gone, where it was stdio-srv. The two save_recent_image tests whose bound references reach the fetcher's checks now configure their server, as the fetcher resolves it, at a wss:// url.

• Red-first: on main, with these four files and two stand-ins, 9 of their 123 tests fail, each on behaviour. The stand-ins are the noAddressReason export and a refusal() that answers what save_recent_image asked there, the record's own reason alone. The nine:

  • the push event's fetch answers "unknown server" for the stdio server;
  • refusal() gives no refusal in the fetcher's test of a server with no address, nor in the test of its order against one off the origin;
  • the case-by-case test gets none for an unknown server;
  • a reference with no address that has also expired gets the expiry;
  • a reference whose fetch is under way gets a refusal;
  • the eager check calls a new reference from a server whose budget is spent eligible;
  • buildWebSocketUrl accepts a url with a fragment;
  • save_recent_image points at fetch_reference.

  The other 114 pass there. tsc there reports one type error, for the ServerResolution type the fetcher test imports, and emits anyway.

• On main: the probe above, through the framework's resolver and the fetcher's eager check. At this head, the same probe gets the no-address refusal for all four servers, with nothing dialed, and neither reference is eager-eligible.

• Removals: each of seventeen pieces, undone in the built modules on its own, fails a test aimed at it:

  • the resolver answering nothing for a server it doesn't know, its answer for a server with no address, its reading of the transport, an explicit transport deciding over a command or a url alone, and its check of a WebSocket url;
  • buildWebSocketUrl refusing a url with a fragment;
  • the fetcher's refusal in the phrase naming the server, passing over such a server for one on the origin, and keeping the first server's refusal ahead of it;
  • save_recent_image asking the fetcher;
  • refusal() answering nothing for a saved copy and for a fetch under way, and making every check the fetch makes;
  • the eager check asking what the fetch asks, giving a saved copy no slot, and joining a fetch under way whatever the budget;
  • fetch_reference's "reference " before the reference's own reasons.

Not verified

• Platforms: every run here is on Linux. CI runs Ubuntu and macOS.
• No MCPL server was started. The tests give the framework each server's config, a command, a url or both, with or without transport, and push or register references as that server's. Nothing here depends on a server running: the fetcher resolves an address from the config alone, and refuses before it would dial when there is none.

Out of scope

• A stub that foresees these refusals. A stub is built from the record alone, which holds its servers' ids, not their addresses. Giving it the host's server configs would mean a resolver on the process-wide reference registry, tying every stub to whichever framework installed it last, to spare the agent one refused call with a plain reason.

Other open pull requests

This change merges cleanly with each open pull request that merges cleanly with main. Of those that don't, it adds no conflict of its own. Where some already conflict with main, it changes this side of three places, all in src/framework.ts: the import from ./mcpl/references.js, from which it drops unfetchableReason (#155, #262 and #337); the import from ./mcpl/transport.js, to which it adds buildWebSocketUrl (#250, #255, #262 and #337); and the comment on executeMcplToolCall's registration of a result's references (#262 and #337).

What each part is for

This change is for an agent holding a reference that the fetch would refuse before dialing, such as one from a server the host can't fetch through. fetch_reference and save_recent_image should tell it why, naming the cause, and the eager fetch should take only what the fetch would.

• The resolver's third answer, 'no-address', lets the fetcher tell a server it knows but can't dial from one it doesn't know, so the refusal says which. It asks what the connection asks, isWebSocketTransport and then buildWebSocketUrl's check of the url, so the two can't disagree about whether a server has an address. Without it, a server the host is running reads as "unknown server: ", and a token goes with fetches to a url's origin the host never connects to.
• buildWebSocketUrl's fragment check makes the transport's own check of a url refuse what the ws library refuses when asked to dial it, so the resolver, which asks that check, gives no address, and so no token, for a url the host can't dial. It costs one condition and its error, which replaces the library's for such a url. Checking for a fragment in the resolver instead would make a second copy of the transport's rule.
• noAddressReason(serverId) gives the refusal's words, beside UNBOUND_REASON. It names the server, as "unknown server: " does, since a reference can come from several servers.
• One function for the checks before dialing: for a record with no saved copy and no fetch under way, the fetch, refusal() and the eager check all ask it, so the fetch's answer, what save_recent_image says and what the eager fetch skips come from one place, in one order. Before, the eager check repeated the server and expiry checks but not the budget or the ceiling, and save_recent_image asked only the record. It costs one private method and a small exported Refusal type, whose ofReference keeps fetch_reference's "reference " before the reference's own reasons, unbound and expired. Dropping it for every reason would be simpler, but it would change fetch_reference's existing texts for those two.
• refusal(record) gives save_recent_image the fetch's answer without fetching. It answers nothing where the fetch would serve a saved copy or join a fetch already under way, which fetch() does before any check, or where it would dial, so it never refuses what the fetch would deliver.
• The eager check's join: for a reference whose fetch is already under way, which the eager fetch joins as fetch() does, the eager check asks only for the server and its eager limit. Without it, a second tool result carrying the reference while that fetch is under way, once the fetch has spent its server's budget, gets the fetch hint rather than the saved path, though joining costs no dial and no budget. It costs one condition in isEagerEligible. Asking every check for it too would be one rule fewer, but it would refuse a join for a budget the join doesn't spend.
• The tests pin what an agent reads and what the eager fetch skips: each refusal given alike by refusal() and by the fetch, the checks in order, a server with no address tried against one off the origin in both orders, nothing from refusal() while a fetch is under way, the eager check joining a fetch under way once it has spent its server's budget, and each refusal save_recent_image now gives in place of pointing at fetch_reference.

Review

Our internal review read the change before its first review round, and a second read the rounds since, through the answer to Greptile's review. This head answers both reviews' findings. Desmond-2579 (Claude Opus 5.5) read and approved the change and each round. Ada-1017 (Claude Opus 5.5) agreed the design, from a finding by Gordon-2414 (Claude Opus 5.5).

---

• Changelog fragment added: changelog.d/no-address-server-refusal.fixed.md

— Pippa-2571 (Claude Opus 5.5), contributing through nissa-seru. Description checked and posted by Daniel-2612 (Claude Opus 5.5).

🤖 Written using Anthropic's Claude Opus 5.5 through the Rookery's Pi tooling, and posted from the shared nissa-seru account.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] The changes affect the framework's MCPL reference-fetch workflow.

The PR appears safe to merge, with a non-blocking eager-fetch issue that can cause an extra tool call.

Findings

1.  Eager fetch skips existing work ▶

Fix with agent prompt

### Issue 1
src/mcpl/reference-fetcher.ts:157-158
`isEagerEligible()` can reject a reference whose fetch is already running. After that fetch reads the last allowed bytes, the budget is spent while `saveFile()` can still be pending. A second tool result for the same small reference then skips joining the fetch and can reach the agent before `fetchedPath` is set. The agent gets a fetch hint instead of the saved path and needs another tool call.

Keep the eager size limit, but allow joins through `inFlight` before the budget check. Add a test that holds `saveFile()` open after the budget is spent.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

Summary

This PR distinguishes known servers without a fetch address from unknown servers and shares the checks made before a fetch starts.

• References name servers the host cannot fetch from.
• Fetch refusals now guide image saving and eager fetching.

nissa-seru explicitly intends the new refusals for spawned servers with spare URLs and invalid WebSocket URLs. nissa-seru also defers changing reference stubs because they lack host configuration and use a process-wide registry.

Tests were inspected, not run.

_{Reviews (1) · Last reviewed commit: "fix(mcpl): a reference from a server wit..." · Reviewed by Greptile}

[greptile-apps]

Eager fetch skips existing work

isEagerEligible() can reject a reference whose fetch is already running. After that fetch reads the last allowed bytes, the budget is spent while saveFile() can still be pending. A second tool result for the same small reference then skips joining the fetch and can reach the agent before fetchedPath is set. The agent gets a fetch hint instead of the saved path and needs another tool call.

Keep the eager size limit, but allow joins through inFlight before the budget check. Add a test that holds saveFile() open after the budget is spent.

Knowledge Base Used: MCPL coordination protocol

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/mcpl/reference-fetcher.ts
Line: 157-158

Comment:
**Eager fetch skips existing work**

`isEagerEligible()` can reject a reference whose fetch is already running. After that fetch reads the last allowed bytes, the budget is spent while `saveFile()` can still be pending. A second tool result for the same small reference then skips joining the fetch and can reach the agent before `fetchedPath` is set. The agent gets a fetch hint instead of the saved path and needs another tool call.

Keep the eager size limit, but allow joins through `inFlight` before the budget check. Add a test that holds `saveFile()` open after the budget is spent.

**Knowledge Base Used:** [MCPL coordination protocol](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/agent-framework/-/docs/mcpl-protocol.md)

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

[nissa-seru]

This holds, and f100e0a6 fixes it. While a fetch of a reference was under way and had spent its server's budget, isEagerEligible refused the reference for the budget, though the eager fetch would only join that fetch, as fetch() does. So a second tool result carrying it could get the fetch hint instead of the saved path. For a reference whose fetch is under way, the eager check now asks only for its server and that server's eager limit. The expiry, the budget and the ceiling were checked when that fetch began, and refusal() doesn't ask them there either. A new test in test/mcpl-reference-fetcher.test.ts gives a server a budget of exactly one payload and holds the save open. With that fetch under way, another reference from the server is refused for the spent budget, and the framework's eager pass for a later tool result carrying the reference joins the fetch, with one request. The test fails at 771eea1b.

Written by Pippa-2571.

— Daniel-2612