@animalabs/agent-framework 0.26.1 → 0.26.2

package/src/mcpl/references.ts

@@ -455,8 +455,8 @@ export function referenceStubOrNull(block: unknown, provenance?: string, serverI
  * 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 value 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,
+ * 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
@@ -470,8 +470,8 @@ export function referenceStubOrNull(block: unknown, provenance?: string, serverI
  * 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 value, the withheld
- * notice, each as a text block.
+ * 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.
  * A text block, or inline data that claims nothing, is returned as sent.
  */
 export function referenceBlockForScript(block: unknown, serverId?: string): unknown {
@@ -480,7 +480,7 @@ export function referenceBlockForScript(block: unknown, serverId?: string): unkn
     case 'text': return block;
     case 'inline': {
       // A script reads every field, as history's JSON writes it, so inline
-      // data beside a uri of any value is withheld here, not only beside a
+      // data beside a uri of any type is withheld here, not only beside a
       // string one as in the model's lanes, which show no uri: an object can
       // carry a credential. An absent or null uri carries none; a string one,
       // an empty one included, is already the classifier's contradiction.

package/src/tool-result-history.ts

@@ -229,9 +229,10 @@ function shownInHistory(value: unknown): unknown {
   const b = value as Record<string, unknown>;
   if (!governedByRfc005(b)) return value;
   if ((b.type === 'image' || b.type === 'audio') && typeof b.data === 'string') {
-    // JSON writes every field, so here inline data beside a uri of any value
+    // JSON writes every field, so here inline data beside a uri of any type
     // is withheld, not only beside a string one as in the lanes, which show
-    // no uri: an object can carry a credential. An empty uri carries none.
+    // no uri: an object can carry a credential. A null, absent or empty uri
+    // carries none (hasUri).
     return hasUri(b.uri) || b.disposition !== undefined ? INLINE_WITHHELD_TEXT : value;
   }
   return referenceStubOrNull(b, 'from tool result') ?? value;
@@ -243,7 +244,9 @@ function shownInHistory(value: unknown): unknown {
  * RFC-005 governs is shown as the script lane shows it, a reference as its
  * stub's facts without its uri and an invalid one as the notice
  * (referenceBlockForScript), and inline data that also claims a uri of any
- * value or a disposition as the withheld notice, each as a text block. Any
+ * type or a disposition as the withheld notice, each as a text block. A
+ * null, absent or empty uri claims none (hasUri), so inline data beside one
+ * is itself. Any
  * other value is itself. What it gives is either a stub or a notice, which
  * RFC-005 doesn't govern, or the value itself, which it gives again, so
  * applying it twice gives what applying it once gave.
@@ -258,6 +261,22 @@ export function shownToScript(value: unknown): unknown {
   return referenceBlockForScript(b);
 }
 
+/**
+ * A value nested in an MCPL peer's content block as a script reads it, as a
+ * JSON replacer applies it inside the blocks: what RFC-005 governs
+ * (governedByRfc005, history's guard, since the classifier would make a
+ * notice of an object that isn't a content block, such as a peer's own
+ * nested data) gets the treatment the script lane gives a
+ * peer's block (referenceBlockForScript), its reference bound to the server
+ * that sent it, and any other value is itself. A stub or a notice isn't
+ * governed, so a block the top-level pass already treated is left as it is.
+ */
+export function shownToScriptFromServer(value: unknown, serverId: string): unknown {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
+  const b = value as Record<string, unknown>;
+  return governedByRfc005(b) ? referenceBlockForScript(b, serverId) : value;
+}
+
 /**
  * The text RFC-005 shows a value of a tool result's data as, when it shows it
  * as text rather than as its fields: a reference's stub, an invalid one's

package/src/types/events.ts

@@ -299,7 +299,10 @@ export interface ToolCall {
    * leaves room for them; and a result nested past 2,000 levels, or whose parse
    * needs more of the script's memory than is free, doesn't reach the script
    * whatever its length. A result that doesn't reach it is answered
-   * ResultTooLarge, the call having taken effect. Nothing is cut or saved to
+   * ResultTooLarge, the call having taken effect. One the host can't convert
+   * to JSON at all, such as one nested deeper than its runtime's
+   * JSON.stringify can take, is answered instead as a failure naming the
+   * tool and saying the call itself completed. Nothing is cut or saved to
    * a file. A tool that pages or budgets its answer can stay under it. The
    * framework sets it on a model's, a script's and the operator's puppet's
    * call to a module, a utility run through `utils` included. A call