@tangle-network/agent-provider-tangle 1.1.6 → 1.1.8

package/README.md

@@ -102,6 +102,11 @@ Reconstruct an exact session with `environment.session(reference.id, { controlRe
 Result, replay, and cancel operations select that exact execution instead of whichever execution most recently changed the shared session.
 Session status with an exact control reference reports a state only when the payload names that execution; a payload bound to a different or unnamed execution reports `unknown`.
 
+Stream frames can contain complete tool output and cumulative assistant text.
+The adapter bounds each complete serialized frame to 1 MiB of UTF-8, including keys and JSON escaping.
+It retains accepted content without truncation in the event data and original provider event.
+Identifiers, usage metadata, and structural JSON limits retain their existing bounds.
+
 ## Two capability documents
 
 Capabilities are derived in two stages, and the two stages answer different questions.

package/dist/tangle-contract-safety.d.ts

@@ -21,3 +21,6 @@ export declare function validateExactProcessCreateInput(input: CreateAgentExactP
 export declare function awaitWithSignal<T>(operation: Promise<T> | T | undefined, signal?: AbortSignal): Promise<T>;
 /** Await an operation and clean its result if abort wins before it resolves. */
 export declare function awaitWithSignalAndCleanup<T>(operation: () => Promise<T> | T, signal: AbortSignal | undefined, cleanup: (value: T) => Promise<void> | void): Promise<T>;
+export declare function cloneJson<T>(value: T): T;
+export declare function safeIdentifier(value: unknown): string | undefined;
+export declare function safeString(value: unknown): string | undefined;

package/dist/tangle-contract-safety.js

@@ -11,13 +11,10 @@ export const MAX_JSON_DEPTH = 16;
 export const MAX_JSON_NODES = 8_192;
 const IMMUTABLE_TANGLE_IMAGE = /^(?:sha256:[a-f0-9]{64}|\S+@sha256:[a-f0-9]{64})$/i;
 export function boundedIdentifier(value, label) {
-    if (typeof value !== "string" ||
-        value.length === 0 ||
-        value.length > MAX_IDENTIFIER_LENGTH ||
-        value.trim() !== value) {
+    const identifier = safeIdentifier(value);
+    if (identifier === undefined)
         throw new Error(`${label} is invalid`);
-    }
-    return value;
+    return identifier;
 }
 export function boundedString(value, label) {
     if (typeof value !== "string" || value.length > MAX_STRING_LENGTH) {
@@ -269,3 +266,22 @@ export async function awaitWithSignalAndCleanup(operation, signal, cleanup) {
             signal.removeEventListener("abort", listener);
     }
 }
+export function cloneJson(value) {
+    assertBoundedJson(value);
+    return structuredClone(value);
+}
+export function safeIdentifier(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_IDENTIFIER_LENGTH ||
+        value.trim() !== value)
+        return undefined;
+    return value;
+}
+export function safeString(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_STRING_LENGTH)
+        return undefined;
+    return value;
+}

package/dist/tangle-events.js

@@ -1,5 +1,4 @@
-import { CanonicalStreamEventSchema, } from "@tangle-network/agent-interface";
-import { assertBoundedJson } from "./tangle-contract-safety.js";
+import { CanonicalStreamEventSchema, boundedEventContentRecordSchema, } from "@tangle-network/agent-interface";
 import { optionalNonEmptyString } from "./tangle-environment-values.js";
 import { tokenUsageFromData } from "./tangle-result-values.js";
 /** The sidecar sends this envelope when an SSE connection is ready. */
@@ -135,8 +134,7 @@ export function environmentEventFromSandboxEvent(event, expected = {}) {
         throw new Error("Tangle Sandbox event contained an invalid event id");
     }
     const data = record.data;
-    assertBoundedRecord(data);
-    assertBoundedJson(record);
+    assertBoundedRecord(record);
     if (Object.prototype.hasOwnProperty.call(data, "contextTransferReceipt")) {
         throw new Error("Tangle Sandbox emitted an unsolicited context transfer receipt");
     }
@@ -328,60 +326,8 @@ function detailFromSandboxData(data) {
     return detail === undefined ? {} : { detail };
 }
 function assertBoundedRecord(value) {
-    if (Object.keys(value).length > 256) {
-        throw new Error("Tangle Sandbox event data has too many fields");
-    }
-    const pending = [
-        { value, depth: 0 },
-    ];
-    const ancestors = new Set();
-    let nodes = 0;
-    while (pending.length > 0) {
-        const item = pending.pop();
-        if (!item)
-            continue;
-        nodes += 1;
-        if (nodes > 8_192)
-            throw new Error("Tangle Sandbox event data has too many JSON nodes");
-        const current = item.value;
-        if (item.leave) {
-            ancestors.delete(current);
-            continue;
-        }
-        if (current === null || typeof current === "boolean")
-            continue;
-        if (typeof current === "string" || typeof current === "number") {
-            if (typeof current === "string" && current.length > 16_384) {
-                throw new Error("Tangle Sandbox event data exceeded its string bound");
-            }
-            if (typeof current === "number" && !Number.isFinite(current)) {
-                throw new Error("Tangle Sandbox event data contained a non-finite number");
-            }
-            continue;
-        }
-        if (typeof current !== "object" || item.depth >= 16 || ancestors.has(current)) {
-            throw new Error("Tangle Sandbox event data exceeded its JSON bound");
-        }
-        ancestors.add(current);
-        pending.push({ value: current, depth: item.depth, leave: true });
-        if (Array.isArray(current)) {
-            if (current.length > 1_024) {
-                throw new Error("Tangle Sandbox event data has too many array entries");
-            }
-            for (const entry of current)
-                pending.push({ value: entry, depth: item.depth + 1 });
-            continue;
-        }
-        if (Object.getPrototypeOf(current) !== Object.prototype && Object.getPrototypeOf(current) !== null) {
-            throw new Error("Tangle Sandbox event data must be plain JSON");
-        }
-        const keys = Object.keys(current);
-        if (keys.length > 256)
-            throw new Error("Tangle Sandbox event map is too large");
-        for (const key of keys) {
-            if (key.length > 512)
-                throw new Error("Tangle Sandbox event key is too long");
-            pending.push({ value: current[key], depth: item.depth + 1 });
-        }
+    const parsed = boundedEventContentRecordSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new Error("Tangle Sandbox event exceeded its JSON content bound", { cause: parsed.error });
     }
 }

package/dist/tangle-prompt.js

@@ -1,4 +1,4 @@
-import { agentProfileSchema, AgentExactRunControlRefSchema, AgentTurnInputSchema, ContextTransferReceiptSchema, contextTransferResultMatchesRequest, } from "@tangle-network/agent-interface";
+import { agentProfileSchema, boundedEventContentRecordSchema, AgentExactRunControlRefSchema, AgentTurnInputSchema, ContextTransferReceiptSchema, contextTransferResultMatchesRequest, } from "@tangle-network/agent-interface";
 import { tokenUsageFromData } from "./tangle-result-values.js";
 import { assertBoundedJson, boundedString } from "./tangle-contract-safety.js";
 export function promptFromTurnInput(input) {
@@ -372,7 +372,12 @@ export function validatedSandboxPromptResult(result) {
     // `undefined`. They were absent on the JSON wire and must stay absent in the
     // provider-neutral result before the strict JSON check runs.
     const record = Object.fromEntries(Object.entries(source).filter(([field, value]) => value !== undefined || !SANDBOX_OPTIONAL_RESULT_FIELDS.has(field)));
-    assertBoundedJson(record);
+    const content = boundedEventContentRecordSchema.safeParse(record);
+    if (!content.success) {
+        throw new Error("Tangle prompt result exceeded its JSON bound", { cause: content.error });
+    }
+    // Response text is content; all other fields retain their metadata limits.
+    assertBoundedJson(Object.fromEntries(Object.entries(record).filter(([field]) => field !== "response" && field !== "text" && field !== "finalText")));
     if (typeof record.success !== "boolean") {
         throw new Error("Tangle prompt result omitted its success status");
     }

package/dist/tangle-result-values.js

@@ -19,7 +19,11 @@ export function execResultFromSandboxExecResult(result) {
     };
 }
 export function tokenUsageFromData(data) {
-    assertBoundedJson(data);
+    // The enclosing event or result has its own content bound.
+    // Apply metadata limits only to fields used to compute usage.
+    assertBoundedJson(Object.fromEntries(["usage", "tokenUsage", "costUsd", "totalCostUsd"]
+        .filter((field) => Object.hasOwn(data, field))
+        .map((field) => [field, data[field]])));
     if (data.usage !== undefined &&
         (!data.usage || typeof data.usage !== "object" || Array.isArray(data.usage))) {
         throw new Error("Tangle usage must be an object");