@animalabs/agent-framework 0.26.2 → 0.28.0

package/dist/src/mcpl/references.d.ts

@@ -20,7 +20,8 @@
  *    retires).
  *
  * The ReferenceRegistry is the host-private reference record (§6.2): raw
- * URIs and testimony live here and never in model-visible content. Fetching
+ * URIs and testimony live here, and model-visible content shows a uri only
+ * as a tool result's link line shows one (shownLinkUri). Fetching
  * (§6/§7 origin binding, ceilings, redirects) is deliberately not here yet —
  * the registry is what makes a future host-mediated fetcher and the
  * code-execution materialization hook possible.
@@ -43,6 +44,10 @@ export interface ReferenceTestimony {
     disposition?: ReferenceDisposition;
     rejectedFields: string[];
     truncatedFields: string[];
+    /** Set when the testimony is an MCP resource_link's, which claims no
+     *  digest, expiry or disposition. A link is registered but never fetched
+     *  on the side, and its testimony never replaces a record's (register). */
+    fromLink?: true;
 }
 export type BlockClassification = {
     kind: 'text';
@@ -53,11 +58,36 @@ export type BlockClassification = {
     kind: 'reference';
     testimony: ReferenceTestimony;
 }
+/** MCP's embedded resource (embeddedResourceContents): each lane shows
+ *  its contents as it shows the block they make. */
+ | {
+    kind: 'embedded';
+    contents: EmbeddedContents;
+}
 /** `shown` is what the model-visible lanes put in the block's place. */
  | {
     kind: 'invalid';
     shown: string;
 };
+/** What an embedded resource's contents are shown as: the ordinary block
+ *  they make, withheld inline data, or a marker saying why they aren't
+ *  shown. */
+export type EmbeddedContents = {
+    kind: 'block';
+    block: {
+        type: 'text';
+        text: string;
+    } | {
+        type: 'image' | 'audio';
+        data: string;
+        mimeType: string;
+    };
+} | {
+    kind: 'withheld';
+} | {
+    kind: 'marker';
+    text: string;
+};
 export declare function classifyBlock(block: unknown): BlockClassification;
 /** RFC-005 vector 2: an inline-data block claiming bulk disposition (or
  *  smuggling a uri beside its data) is an emitter contradiction — the host
@@ -72,6 +102,26 @@ export declare const AUDIO_NO_MEDIA_TYPE_TEXT = "[Audio not shown: its data arri
  *  inline data, so a plain link isn't enough either. (A tool result's audio
  *  with a link is a reference, as any block with one is there.) */
 export declare const AUDIO_NO_DATA_TEXT = "[Audio not shown: it arrived with no usable inline data.]";
+/** MCP's embedded resource whose contents are neither text nor a blob, or
+ *  both. */
+export declare const EMBEDDED_RESOURCE_UNREADABLE_TEXT = "[Resource not shown: its contents arrived as neither text nor data, or as both.]";
+/** MCP's embedded resource whose blob has no media type, so it can't be
+ *  shown as an image or audio. */
+export declare const EMBEDDED_RESOURCE_NO_MEDIA_TYPE_TEXT = "[Resource not shown: its data arrived without a media type.]";
+/** MCP's embedded resource whose blob is of a type no lane can show: what
+ *  it was, by its type and size. Made well formed (a lone UTF-16 surrogate
+ *  becomes U+FFFD), as a stub is (#695), since it names the block's media
+ *  type, which sanitizeLabel leaves as it is: every lane then shows the same
+ *  text. */
+export declare function embeddedBinaryText(mimeType: string, blob: string): string;
+/**
+ * What the converter (convertBlock, on every lane) shows for a text
+ * block whose text isn't a string, which only a nonconformant sender writes,
+ * so the agent learns that a block was there. It is the host's word, not the
+ * sender's, so it never makes content visible (isVisiblyEmptyConversion in
+ * visible-content.ts, which re-exports it).
+ */
+export declare const NON_STRING_TEXT_PLACEHOLDER = "[Text not shown: a text part arrived without readable text.]";
 export declare const REFERENCE_NO_LINK_TEXT = "[Reference not shown: it arrived without a link.]";
 export declare const REFERENCE_LINK_TOO_LONG_TEXT = "[Reference not shown: its link is longer than this host accepts.]";
 /** A block of a type the host doesn't show, of no type at all, or no block.
@@ -101,17 +151,120 @@ export declare const EXPIRY_REASON: {
  *  the fetcher's refusal and save_recent_image's all say it: the fetcher dials
  *  only through a server that delivered the reference. */
 export declare const UNBOUND_REASON = "not tied to any server, so there's nowhere to fetch it from";
-/** The fetcher's refusal for a server it has no address to dial, one the
- *  host doesn't connect to over a network, such as a stdio server, as a
- *  clause that completes "couldn't fetch <ref>: " and says so of the server;
- *  the fetcher dials only through a server's address. save_recent_image gives
- *  it too. A stub can't know it, since only the framework holds its servers'
- *  configs. */
+/** The refusal for a server the host has no address to dial, one it doesn't
+ *  connect to over a network, such as a stdio server, as a clause that
+ *  completes "couldn't fetch <ref>: " and says so of the server: the fetcher
+ *  dials only through a server's address. A reference's stub, fetch_reference
+ *  and save_recent_image all give it (dialCheck). */
 export declare function noAddressReason(serverId: string): string;
-/** Strip control characters (C0, DEL, C1) and every bidi control (marks,
- *  embeddings, overrides, isolates, and the Arabic letter mark), trim the
- *  whitespace (a BOM included) left at either end, and bound the length.
- *  Labels are labels — storage naming is host-generated elsewhere (§7.3). */
+/** A server's id as the agent reads it in a stub or a refusal: as a label
+ *  is, bounded and with its controls removed. */
+export declare function shownServerId(serverId: string): string;
+/**
+ * Whether a uri may carry a credential: userinfo, or a query or fragment
+ * parameter named on CREDENTIAL_PARAMETERS with a value, a fragment read as
+ * `name=value&…` as a query is. A name with no value carries nothing, as an
+ * anchor (`#token`) or `?token=` doesn't. A `?` or `;` inside either may
+ * separate parameters too, as in a route kept in a fragment
+ * (`#/reset?token=…`), so the parameters are read both with and without them
+ * as separators, and one with a value in either reading counts. A
+ * parameter's value that is itself a uri is read the same way
+ * (nestedMayCarry): an absolute one, as an image proxy's `?url=<a
+ * percent-encoded signed URL>` is once decoded; a protocol-relative one, or
+ * a relative one with a query or fragment, as a login's
+ * `?next=%2Freset%3Ftoken%3D…` is; and one encoded again inside the value,
+ * as a redirector that encodes an already encoded url leaves it, each read
+ * and each decode a level of its own. That goes up to CREDENTIAL_NESTING
+ * levels deep, and a uri reached deeper may carry one, since a bound that
+ * let the next level through would be the same gap one level down. A uri
+ * carried in another encoding, such as base64, isn't read. A uri that
+ * doesn't parse, even as a relative reference, may, since its parts can't be
+ * read.
+ */
+export declare function uriMayCarryCredential(uri: string): boolean;
+/** How the host reaches a server, as far as fetching its references goes:
+ *  the WebSocket url it dials an MCPL server at, or none: for a server it
+ *  spawns, such as a stdio one, or a modern MCP server over HTTP, whose
+ *  results carry no references (RFC-005 governs MCPL peers' alone), or one
+ *  whose url the transport won't dial. A framework records each of its
+ *  servers' in the registry (ReferenceRegistry.setServerAddress), where a
+ *  stub reads it; its fetcher reads the same from the framework's own
+ *  configs, beside each server's credential. */
+export type ServerAddress = {
+    url: string;
+} | 'no-address';
+/** Why a fetch of a reference failed, or would be refused before it dials. */
+export interface Refusal {
+    /** What happened, as a clause that completes "couldn't fetch <ref>: ",
+     *  whatever it's about: fetch_reference's sentence, save_recent_image's,
+     *  and the eager and script-demand fetches' log lines read it. */
+    error: string;
+    /** What calling again can do, as a sentence. fetch_reference and
+     *  save_recent_image show it; the eager and script-demand fetches log the
+     *  error alone, and a reference's stub never shows it. */
+    remedy: string;
+    /** How the reference's stub words it, where the clause names parts of the
+     *  uri the stub never shows. A stub shows this or the clause. */
+    inStub?: string;
+}
+export declare const NOTHING_TO_DO = "Calling again won't change that.";
+/** The registry keys a record by its uri, so a fresh reference to the same
+ *  uri arrives as this very id and refreshes its record. */
+export declare const FRESH_REFERENCE = "Once a fresh reference to it arrives, fetching may work; until then, fetching it again won't.";
+/** A server's address is read from the host's configs as they are at each
+ *  fetch. */
+export declare const SERVER_BACK = "Calling again won't change that unless whoever runs this host adds that server back.";
+/** ws→http / wss→https with default ports elided, for origin comparison. */
+export declare function normalizedOrigin(url: string): string | null;
+/**
+ * The server a fetch of a reference would dial: its servers, in the order
+ * they delivered it, the first whose address is on the uri's origin (§6.2).
+ * When none is, the first server's refusal (unknown to this host, with no
+ * address, or the origin check's), and for a record no server delivered,
+ * that it's unbound, which a later delivery of the uri by a server mends.
+ */
+export declare function dialServer(record: ReferenceRecord, addressOf: (serverId: string) => ServerAddress | undefined): {
+    serverId: string;
+} | {
+    refusal: Refusal;
+};
+/**
+ * Where a fetch of a reference would dial, or why it would be refused before
+ * dialing, whatever the fetch: dialServer's server, then the reference's
+ * expiry. A pure function of the record and the servers' addresses: a
+ * reference's stub asks it of the registry's (unfetchableReason), and the
+ * fetcher's pre-dial check of its own framework's configs, whose credential
+ * goes with the address it checks. In a process with one running framework,
+ * or with running frameworks that agree on each id they share, the two
+ * sources hold the same addresses, so a stub promises the server the fetch
+ * dials. A stub reads an expiry with its result's claims, and the fetch with
+ * the record's latest testimony, so where one result names a uri both
+ * expired and fresh, its stub says expired while a fetch can succeed. A
+ * stopped framework's addresses are out of the registry, so its stubs read
+ * another running framework's entry for the same id where there is one, and
+ * otherwise say the server is unknown, while its configs still resolve it.
+ * Where two
+ * frameworks configure one id differently, only a stub's words can be wrong,
+ * never where a token goes. A fetch's own limits, its budget and ceiling,
+ * come after it.
+ */
+export declare function dialCheck(record: ReferenceRecord, addressOf: (serverId: string) => ServerAddress | undefined, nowMs?: number, 
+/** For a stub or a script's object, the claims of the result it's shown
+ *  in, which decide where its references name the record's uri, the
+ *  record's own testimony deciding otherwise (claimedExpiry). A fetch
+ *  reads the record alone. */
+claims?: ResultClaims): {
+    serverId: string;
+} | {
+    refusal: Refusal;
+};
+/** Strip control characters (C0, DEL, C1), every bidi control (marks,
+ *  embeddings, overrides, isolates, and the Arabic letter mark) and the line
+ *  and paragraph separators (U+2028, U+2029), which a regex reads as line
+ *  ends, so a label can't start a line of its own, such as one the image
+ *  ledger would read as a slot. Then trim the whitespace (a BOM included)
+ *  left at either end, and bound the length. Labels are labels — storage
+ *  naming is host-generated elsewhere (§7.3). */
 export declare function sanitizeLabel(s: string, maxChars: number): string;
 export declare function formatSizeBytes(n: number): string;
 export interface ReferenceRecord {
@@ -128,6 +281,13 @@ export interface ReferenceRecord {
     verifiedBytes?: number;
     verifiedMimeType?: string;
     digestVerified?: boolean;
+    /** Set when the eager default's fetch of it failed, so the eager default
+     *  doesn't choose it again; fetch_reference still fetches it. A refreshed
+     *  testimony leaves it set, since a server can re-issue a uri at every
+     *  result, and it lasts as long as the record. A record fetched later, by a
+     *  save that landed after the eager pass stopped waiting or by
+     *  fetch_reference, can carry it too: fetchedPath is read first. */
+    eagerFailed?: boolean;
 }
 /**
  * Host-private store of received references. Raw URIs live here and in stubs
@@ -144,7 +304,7 @@ export interface ReferenceRecord {
 export declare class ReferenceRegistry {
     private records;
     /** uri → refId. The uri ALONE is the identity key: a tool result's stubs
-     *  (tool-result-history.ts's, and framework.ts's tryNativeToolResultContent)
+     *  (tool-result-history.ts's, which both copies of a tool result take)
      *  and a script's demand fetch register with no server context,
      *  while the registrations that know the server carry its id: a tool
      *  result's, before it's shown, whether the agent's dispatch or an
@@ -161,77 +321,251 @@ export declare class ReferenceRegistry {
      *  its own origin, for a uri it delivered. */
     private byKey;
     private counter;
+    /** Each open journal's copies (openJournal), by uri. */
+    private journals;
+    /**
+     * Keep, until `close`, each record as it stood when this opened: a copy
+     * taken the first time a registration names its uri, whatever it changes,
+     * or evicts its record, or null where the uri had none then. `before(uri)`
+     * gives that copy, or, where no registration has named the uri since, the
+     * record as it is, which is the same. A fetch that saves a copy while it's
+     * open sets its record's saved path without registering: a record no
+     * registration has named since is read with it, and one a registration
+     * named first is read as it stood then, saved or not. For a record a fetch
+     * saved meanwhile, both readings are of one the host can fetch, since a
+     * fetch saves only what passed the checks a link's line reads too, except
+     * where two frameworks configure one server id differently, which a stub's
+     * words can't tell apart either (setServerAddress). Each
+     * open has its own copies, so lanes that overlap keep theirs apart, and
+     * closing one lets its copies go.
+     */
+    openJournal(): RegistryJournal;
+    /** Copy a uri's record into each open journal that has none for it yet,
+     *  a copy of its own for each. */
+    private keepFirst;
+    /** How many journals are open: none once every lane has closed its own. */
+    get journalCount(): number;
     register(testimony: ReferenceTestimony, serverId?: string): ReferenceRecord;
     get(refId: string): ReferenceRecord | undefined;
+    /** How the host reaches each server, by id, as each framework in the process
+     *  configured it, which a reference's stub reads (unfetchableReason). A
+     *  fetch reads its own framework's configs instead, so a server's token only
+     *  ever goes to the origin its own config names. Keyed by id as a record's
+     *  servers are: where two frameworks configure one id, the latest entry is
+     *  in force, and a stub's words can be wrong for the other one's fetch. */
+    private addresses;
+    /** Record how the host reaches a server, as a framework (`owner`) does for
+     *  each server it configures. Its entry for the id is then in force. */
+    setServerAddress(serverId: string, address: ServerAddress, owner: object): void;
+    /** Take back a framework's entry for a server, as it does for a server it
+     *  removes, and for each of its servers when it stops. Another framework's
+     *  entry for the id, if any, is in force again; with none, a stub reads the
+     *  id's references as an unknown server's. After a removal, that framework's
+     *  fetch refuses them too. A stopped framework keeps its configs, so its
+     *  fetcher, called before it starts again, can still dial them. */
+    forgetServerAddress(serverId: string, owner: object): void;
+    serverAddress(serverId: string): ServerAddress | undefined;
     /** Find the record for a uri. */
     findByUri(uri: string): ReferenceRecord | undefined;
 }
 export declare const referenceRegistry: ReferenceRegistry;
+/** A registry's records as they stood when it opened (openJournal). */
+export interface RegistryJournal {
+    before(uri: string): ReferenceRecord | undefined;
+    close(): void;
+}
+/**
+ * The model's line for a result as a script's link object reads it: the
+ * claims that line reads, and each record as it stood when the script lane
+ * began to treat the result (a journal's `before`), whatever the treatment
+ * has registered, rebound or evicted since, which the line never sees.
+ */
+export interface ScriptLine {
+    claims: ResultClaims;
+    recordBefore(uri: string): ReferenceRecord | undefined;
+}
 /** A reference's type as its stub shows one, or '' when nothing is left of
  *  it once sanitized (the stub then leaves it out). */
 export declare function referenceTypeLabel(mimeType: string | undefined): string;
 /**
- * The longest line buildReferenceStub writes, in UTF-16 code units, from its
+ * The longest stub buildReferenceStub writes, in UTF-16 code units, from its
  * own bounds: the longest id the registry mints, then the name, the type with
  * the largest size it shows, and the origin, each at its bound, and the
  * longest ending, a saved copy's path, with their separators. The other
  * endings, the fetch hint and the reasons a fetch would be refused, are
  * shorter. A line shaped like a stub but longer than this is quoted text the
- * writer can't have written, and no image slot (tool-image-ledger.ts).
+ * writer can't have written, and no image slot (tool-image-ledger.ts). A
+ * tool result's link line (StubOptions.unfetchedLinkUri) isn't shaped like a
+ * stub, so it's no slot whatever its length.
  */
 export declare const REFERENCE_STUB_MAX_CHARS: number;
+/** How a lane shows a reference beyond its stub. */
+export interface StubOptions {
+    /**
+     * Show a link (MCP's resource_link) the host can't fetch as its name, uri
+     * and type, unless its uri may carry a credential (uriMayCarryCredential).
+     * For a tool result's links, whose JSON showed every link's uri before
+     * this host read links as references: there the uri is the agent's only
+     * handle on a link the host can't fetch, and showing it is §5's MAY for a
+     * reference the host's policy classifies as non-capability-bearing. No
+     * other lane showed a link's uri, so none shows one now.
+     */
+    unfetchedLinkUri?: boolean;
+    /** The claims of the result this block is shown in (resultClaims), which
+     *  decide what the stub says where its references name the record's uri,
+     *  the record's own testimony deciding otherwise. */
+    claims?: ResultClaims;
+}
+/**
+ * What one tool result's references claim of each uri they name, each uri's
+ * testimonies read as one (UriClaims): the strictest claim wins, so a uri any
+ * of them marks `disposition: never` is withheld, and one any of them gives
+ * an expiry that counts is expired (claimedExpiry), whatever the order of the
+ * blocks and whatever the registry evicted while it was read (Ada-1017's
+ * call). A decision about a record reads its result's claims where the
+ * result's references name its uri, a plain one included, and otherwise the
+ * record's own testimony, from an earlier result. A reference naming the uri
+ * is that result's word on it, the latest, as the registry keeps it
+ * (register() replaces a record's testimony with it until the record is
+ * fetched), so an earlier result's `never` or expiry gives way to it
+ * (Ada-1017's call). A link claims no disposition or expiry, so it adds
+ * nothing here, and a result that names a uri only in links leaves its
+ * record's testimony in force.
+ */
+export type ResultClaims = ReadonlyMap<string, UriClaims>;
+/**
+ * A uri as a link shows it: cleaned as sanitizeLabel cleans a label (controls
+ * and bidi marks dropped, surrounding space trimmed; a uri past
+ * REFERENCE_LIMITS.uri is no reference, so none is shortened), and well
+ * formed, as every copy is before it's shown, a lone surrogate showing as
+ * U+FFFD. A `never` is about what a link shows, so it's found by this text
+ * (neverShown): a claim of `never` on a uri withholds every link that shows
+ * the same text, two uris that clean alike sharing it. Every other claim is about the record,
+ * which the fetch reads by its raw uri, so it's kept by the raw uri (Ada-1017,
+ * room-203 #202239).
+ */
+export declare function shownUri(uri: string): string;
+/** What a result's references say of one uri, read as one. */
+export interface UriClaims {
+    /** Whether any of them marks it `disposition: never`. */
+    never: boolean;
+    /** Whether any of them gives an expiry rejected as a field. */
+    rejected: boolean;
+    /** Whether any of them gives an expiry that doesn't parse. */
+    unparseable: boolean;
+    /** The earliest expiry any of them gives, in ms since the epoch, or null. */
+    earliestMs: number | null;
+}
+/** A result's claims (ResultClaims), from the testimonies of its references,
+ *  each read once, as referenceExpiry reads an expiry. */
+export declare function resultClaims(testimonies: Iterable<ReferenceTestimony>, nevers?: Iterable<string>): ResultClaims;
+/** The claims of a content array's references, read from its elements as
+ *  the array shows them: an element's own fields, such as an image's
+ *  `_meta`, aren't shown, so a reference inside them doesn't count. */
+export declare function contentClaims(blocks: readonly unknown[]): ResultClaims;
+/** The uri inline content marks `disposition: never`, which counts for that
+ *  uri's claims (resultClaims) though the block is no reference: inline data
+ *  beside its uri, the classifier's contradiction, and MCP's embedded
+ *  resource, whose uri sits under `resource` (Ada-1017, room-203 #206688).
+ *  Null for any other block. A uri that isn't a non-empty string names
+ *  nothing a claim is kept for. */
+export declare function inlineNeverUri(block: unknown, c?: BlockClassification): string | null;
+/** Whether a record's uri is withheld: marked `disposition: never` by its
+ *  result's references, for any uri a link shows as the same text
+ *  (shownUri), or by its own testimony where none of them names it. */
+export declare function claimedNever(record: ReferenceRecord, claims?: ResultClaims): boolean;
+/** The expiry a record counts, as of `nowMs`: the first of EXPIRY_REASON's
+ *  cases its claims give (uriClaims), so the order of the blocks doesn't
+ *  choose the words. Null when none does. */
+export declare function claimedExpiry(record: ReferenceRecord, claims: ResultClaims | undefined, nowMs: number): keyof typeof EXPIRY_REASON | null;
+/**
+ * The uri a tool result's link shows, or null where it shows none: a link
+ * (fromLink) the host can't fetch, whose uri can't carry a credential, and
+ * that no reference withholds with `disposition: never`, keeps its uri, the
+ * agent's only handle on it. A `data:` uri holds its content rather than
+ * naming where it lies, so it's never shown: a link's line isn't a way for
+ * inline data to reach context. A tool result's link line (buildReferenceStub,
+ * unfetchedLinkUri) and a script's object for the link
+ * (referenceBlockForScript) both ask this, so the model and a script, whose
+ * output comes back to the model, see a link's uri alike.
+ *
+ * The credential check reads the uri as it would be shown, with what
+ * sanitizeLabel strips gone, so a uri split by a control character is read
+ * as it would read: `ht\u0000tps://user:pass@…` parses as a path, and shows
+ * as userinfo. A `disposition: "never"` for the uri keeps it out whatever
+ * the link says: any reference's in the same result (claims), for this uri
+ * or one shown as the same text, or, where no reference in the result names
+ * the uri, the record's.
+ */
+export declare function shownLinkUri(t: ReferenceTestimony, record: ReferenceRecord, nowMs?: number, claims?: ResultClaims): string | null;
 /**
- * Build the model-visible stub for a reference. Output length is bounded by
- * host constants and independent of every server-supplied field length.
- * Under `disposition:"never"` the uri is omitted unconditionally; under
- * `ref`/absent it is omitted too — this host's default policy is the opaque
- * id everywhere (the safe default of §5), with retrieval via the record.
+ * Build the model-visible stub for a reference. Its length is bounded by
+ * host constants and independent of every server-supplied field's length:
+ * REFERENCE_STUB_MAX_CHARS. Under `disposition:"never"` the uri is omitted
+ * unconditionally; under `ref`/absent it is omitted too — this host's default
+ * policy is the opaque id everywhere (the safe default of §5), with retrieval
+ * via the record. The one exception is a tool result's link the host can't
+ * fetch (StubOptions.unfetchedLinkUri), which is no stub but a line of its
+ * own, its uri bounded by REFERENCE_LIMITS.uri.
  */
-export declare function buildReferenceStub(t: ReferenceTestimony, provenance?: string, serverId?: string): string;
+export declare function buildReferenceStub(t: ReferenceTestimony, provenance?: string, serverId?: string, options?: StubOptions): string;
 /**
- * Why the fetcher would refuse a reference, as far as its record alone shows,
- * for its stub: no server registered for it, which the fetcher checks first,
- * or its expiry. Null for a saved copy, which the fetcher serves before any
- * check, and when the record shows neither. The fetcher's other refusals rest
- * on what a record doesn't hold: whether any of its servers is known to the
- * host, has an address and is on the uri's origin, the dialed server's fetch
- * budget spent, or a claimed size over the ceiling a fetch is given. The
- * fetcher gives those in its own words, and save_recent_image, in the
- * framework where it can ask the fetcher, says them too.
+ * Why the fetcher would refuse a reference before it dials, whatever the
+ * fetch, in its stub's words: the registry's dialCheck, from its record and
+ * its servers' addresses. Null for a saved copy, which the fetcher serves
+ * before any check, and where a fetch would dial. A fetch's own limits, the
+ * server's spent budget or a claimed size over the ceiling it's given, the
+ * fetcher gives in its own words, and save_recent_image says them too.
  */
-export declare function unfetchableReason(record: ReferenceRecord, nowMs?: number): string | null;
+export declare function unfetchableReason(record: ReferenceRecord, nowMs?: number, claims?: ResultClaims): string | null;
 /**
  * RFC-005 treatment for one MCPL wire block, for the model-visible text
  * lanes. Returns a replacement string, or null when the block should keep
  * its existing (inline/text) handling. A reference's stub carries text taken
  * from the block's own fields, so it's made well formed (a lone UTF-16
  * surrogate becomes U+FFFD), as the context store would make it: a tool
- * result's copies then carry the same text (#695).
+ * result's copies then carry the same text (#695). For MCP's embedded
+ * resource, it's the text for contents that can't be shown (its marker is
+ * well formed where it's made), and null where they can: the caller shows the
+ * block they make (classifyBlock's `embedded`).
  */
-export declare function referenceStubOrNull(block: unknown, provenance?: string, serverId?: string): string | null;
+export declare function referenceStubOrNull(block: unknown, provenance?: string, serverId?: string, options?: StubOptions): string | null;
 /**
  * RFC-005 treatment for one MCPL wire block, for a script's structured
  * result, which carries blocks rather than text. It makes the decision
  * referenceStubOrNull makes for the model's lanes, since what a script prints
  * comes back to the model, except that a script reads every field, so inline
- * data beside a uri of any type but null or absent is withheld, where the
- * model's lanes, which show no uri, withhold it beside a string one. A reference becomes the stub's facts as data,
- * without its URI: the host's reference id, what the server said about it in
- * this block (its labels stripped and bounded as in the stub), and `savedTo`,
- * the workspace path its payload was fetched to, or null when it wasn't
- * (`fetch_reference` takes the id as `ref_id`). An unsaved reference that
- * counts as expired also carries `expired`, the reason the stub gives in
- * place of advising fetch_reference. The reference is registered bound to
- * `serverId`, the server whose tool returned it, as the model's lanes bind
- * a tool result's references, so the fetch its id offers can be made. With
- * no `serverId`, as for a module's result, it's registered as the model's
+ * data beside a uri of any type but null, absent or empty is withheld, where
+ * the model's lanes, which show no uri, withhold it beside a string one that
+ * isn't empty. A reference becomes the stub's facts as data: the host's
+ * reference id, what the server said about it in this block (its labels
+ * stripped and bounded as in the stub), and `savedTo`, the workspace path
+ * its payload was fetched to, or null when it wasn't (`fetch_reference`
+ * takes the id as `ref_id`). Its uri is left out, except that a link (MCP's
+ * resource_link) carries `uri` where the model's line for it shows the uri
+ * (shownLinkUri). An unsaved reference that counts as expired also carries
+ * `expired`, and one the fetcher would refuse carries `unfetchable`, the
+ * words a stub gives in place of advising fetch_reference
+ * (unfetchableReason). Both give why a fetch_reference with the object's
+ * `refId` would be refused, as the result's references claim it, so a link
+ * whose line shows its uri, which the host can't fetch, carries them too: its
+ * line has no id to fetch with. The fetch itself reads the record, which
+ * keeps the latest testimony registered until it's fetched, and then the one
+ * its saved copy was verified against (Ada-1017's call). `claims` are those
+ * of everything the script's view shows (scriptViewClaims), so its other
+ * references count (ResultClaims). The reference is registered bound to
+ * `serverId`, the server whose tool returned it, as the model's lanes bind a
+ * tool result's references, so the fetch its id offers can be made. With no
+ * `serverId`, as for a module's result, it's registered as the model's
  * history registers a module's: the record its uri already has, bound where
  * it arrived (a module's ctx.callTool registers an MCPL peer's references),
  * or a new one bound to no server. A block the classifier
  * rejects becomes the notice the model's lanes show, and inline data that
- * also claims a bulk disposition, or a uri of any type but null or absent
- * (an empty string included), the withheld notice, each as a text block.
+ * also claims a bulk disposition, or a uri of any type but null, absent or
+ * empty, the withheld notice, each as a text block. MCP's embedded resource
+ * becomes the block its contents make, as the model's lanes show it, never
+ * its uri.
  * A text block, or inline data that claims nothing, is returned as sent.
  */
-export declare function referenceBlockForScript(block: unknown, serverId?: string): unknown;
+export declare function referenceBlockForScript(block: unknown, serverId?: string, claims?: ResultClaims, line?: ScriptLine): unknown;
 //# sourceMappingURL=references.d.ts.map

package/dist/src/mcpl/references.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../src/mcpl/references.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"references.d.ts","sourceRoot":"","sources":["../../../src/mcpl/references.ts"],"names":[],"mappings":"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"}