@tangle-network/agent-interface 2.6.0 → 2.7.0

package/dist/contract-limits.d.ts

@@ -18,10 +18,23 @@ export declare const boundedIdentifierSchema: z.ZodString;
  * checked before canonical serialization.
  */
 export declare function isBoundedJsonValue(value: unknown): boolean;
+/**
+ * Validate provider event and terminal content. Unlike ordinary metadata,
+ * content may contain a single large transcript or tool result. It remains
+ * finite, plain JSON with the normal structural limits, and its complete JSON
+ * representation is capped exactly by UTF-8 bytes.
+ */
+export declare function isBoundedEventContentJson(value: unknown, { omitUndefinedObjectFields }?: {
+    omitUndefinedObjectFields?: boolean;
+}): boolean;
 /** Validate digest input while matching JSON's omission of undefined object fields. */
 export declare function isBoundedJsonMaterial(value: unknown): boolean;
 export declare const boundedJsonSchema: z.ZodCustom<unknown, unknown>;
 export declare const boundedJsonRecordSchema: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+/** One provider event payload or terminal response, bounded as serialized UTF-8 JSON. */
+export declare const boundedEventContentJsonSchema: z.ZodCustom<unknown, unknown>;
+export declare const boundedEventContentRecordSchema: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+export declare const boundedEventContentStringSchema: z.ZodCustom<string, string>;
 export declare function assertBoundedJson(value: unknown): void;
 export declare function assertBoundedSerializedJson(value: string): void;
 /** Copy arbitrary metadata into a map that cannot inherit prototype keys. */

package/dist/contract-limits.js

@@ -84,6 +84,162 @@ export function isBoundedJsonValue(value) {
     }
     return true;
 }
+/** Exact serialized JSON UTF-8 byte count for one string scalar. */
+function serializedJsonStringBytes(value) {
+    let bytes = 2; // Opening and closing quotes.
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code === 0x22 || code === 0x5c || code === 0x08 || code === 0x0c || code === 0x0a || code === 0x0d || code === 0x09) {
+            bytes += 2;
+        }
+        else if (code < 0x20) {
+            bytes += 6;
+        }
+        else if (code >= 0xd800 && code <= 0xdbff && index + 1 < value.length) {
+            const next = value.charCodeAt(index + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                index += 1;
+            }
+            else {
+                bytes += 6;
+            }
+        }
+        else if (code >= 0xd800 && code <= 0xdfff) {
+            bytes += 6;
+        }
+        else if (code < 0x80) {
+            bytes += 1;
+        }
+        else if (code < 0x800) {
+            bytes += 2;
+        }
+        else {
+            bytes += 3;
+        }
+        if (bytes > CONTRACT_MAX_JSON_BYTES)
+            return bytes;
+    }
+    return bytes;
+}
+/**
+ * Validate provider event and terminal content. Unlike ordinary metadata,
+ * content may contain a single large transcript or tool result. It remains
+ * finite, plain JSON with the normal structural limits, and its complete JSON
+ * representation is capped exactly by UTF-8 bytes.
+ */
+export function isBoundedEventContentJson(value, { omitUndefinedObjectFields = false } = {}) {
+    const pending = [
+        { value, depth: 0 },
+    ];
+    const ancestors = new Set();
+    let nodes = 0;
+    let bytes = 0;
+    const addBytes = (additional) => {
+        bytes += additional;
+        return bytes <= CONTRACT_MAX_JSON_BYTES;
+    };
+    while (pending.length > 0) {
+        const item = pending.pop();
+        if (!item)
+            continue;
+        const current = item.value;
+        if (current === undefined && item.omitUndefined === true)
+            continue;
+        nodes += 1;
+        if (nodes > CONTRACT_MAX_JSON_NODES)
+            return false;
+        if (item.leave) {
+            ancestors.delete(current);
+            continue;
+        }
+        if (current === null) {
+            if (!addBytes(4))
+                return false;
+            continue;
+        }
+        if (typeof current === "boolean") {
+            if (!addBytes(current ? 4 : 5))
+                return false;
+            continue;
+        }
+        if (typeof current === "string") {
+            if (!addBytes(serializedJsonStringBytes(current)))
+                return false;
+            continue;
+        }
+        if (typeof current === "number") {
+            if (!Number.isFinite(current))
+                return false;
+            if (!addBytes(JSON.stringify(current).length))
+                return false;
+            continue;
+        }
+        if (typeof current !== "object" || item.depth >= CONTRACT_MAX_JSON_DEPTH) {
+            return false;
+        }
+        if (ancestors.has(current))
+            return false;
+        ancestors.add(current);
+        pending.push({ value: current, depth: item.depth, leave: true });
+        if (Array.isArray(current)) {
+            if (current.length > CONTRACT_MAX_ARRAY_LENGTH)
+                return false;
+            if (!addBytes(2 + Math.max(current.length - 1, 0)))
+                return false;
+            const prototype = Object.getPrototypeOf(current);
+            if (prototype !== Array.prototype && prototype !== null)
+                return false;
+            const keys = Reflect.ownKeys(current);
+            const entryKeys = keys.filter((key) => key !== "length");
+            if (entryKeys.length !== current.length)
+                return false;
+            if (entryKeys.some((key) => {
+                if (typeof key !== "string" || !/^(?:0|[1-9][0-9]*)$/u.test(key))
+                    return true;
+                const index = Number(key);
+                return !Number.isSafeInteger(index) || index < 0 || index >= current.length || index >= 4_294_967_295;
+            })) {
+                return false;
+            }
+            for (const key of entryKeys) {
+                const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
+                    return false;
+                pending.push({ value: descriptor.value, depth: item.depth + 1 });
+            }
+            continue;
+        }
+        const prototype = Object.getPrototypeOf(current);
+        if (prototype !== Object.prototype && prototype !== null)
+            return false;
+        const entries = [];
+        for (const key of Reflect.ownKeys(current)) {
+            if (typeof key !== "string" || key.length > CONTRACT_MAX_IDENTIFIER_LENGTH)
+                return false;
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (descriptor === undefined || !descriptor.enumerable || !("value" in descriptor))
+                return false;
+            if (descriptor.value === undefined && omitUndefinedObjectFields)
+                continue;
+            entries.push([key, descriptor]);
+            if (entries.length > CONTRACT_MAX_MAP_ENTRIES)
+                return false;
+        }
+        if (!addBytes(2 + Math.max(entries.length - 1, 0)))
+            return false;
+        for (const [key, descriptor] of entries) {
+            if (!addBytes(serializedJsonStringBytes(key) + 1))
+                return false;
+            pending.push({
+                value: descriptor.value,
+                depth: item.depth + 1,
+                omitUndefined: omitUndefinedObjectFields,
+            });
+        }
+    }
+    return true;
+}
 /** Validate digest input while matching JSON's omission of undefined object fields. */
 export function isBoundedJsonMaterial(value) {
     const pending = [{ value, depth: 0 }];
@@ -158,6 +314,13 @@ export const boundedJsonRecordSchema = z.custom((value) => typeof value === "obj
     value !== null &&
     !Array.isArray(value) &&
     isBoundedJsonValue(value), { message: "metadata exceeds the contract bounds or is not a JSON object" });
+/** One provider event payload or terminal response, bounded as serialized UTF-8 JSON. */
+export const boundedEventContentJsonSchema = z.custom(isBoundedEventContentJson, { message: "event content exceeds its serialized byte bound or is not finite JSON" });
+export const boundedEventContentRecordSchema = z.custom((value) => typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    isBoundedEventContentJson(value), { message: "event content exceeds its serialized byte bound or is not a JSON object" });
+export const boundedEventContentStringSchema = z.custom((value) => typeof value === "string" && isBoundedEventContentJson(value), { message: "event content exceeds its serialized byte bound or is not a string" });
 export function assertBoundedJson(value) {
     if (!isBoundedJsonValue(value)) {
         throw new Error("value exceeds the contract bounds or is not finite JSON");

package/dist/environment-interactive-control.d.ts

@@ -1512,7 +1512,7 @@ export declare const AgentInteractiveSessionPromptCommandSchema: z.ZodObject<{
         holderId: z.ZodString;
         expiresAt: z.ZodISODateTime;
     }, z.core.$strict>;
-    prompt: z.ZodString;
+    prompt: z.ZodCustom<string, string>;
     requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
 }, z.core.$strict>;
 export interface AgentInteractiveSessionPromptAcknowledgement {

package/dist/environment-interactive-control.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { canonicalCandidateDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { agentExecutionPreparationReceiptSchema, } from "./agent-execution-preparation-receipt.js";
-import { boundedIdentifierSchema, boundedStringSchema, } from "./contract-limits.js";
+import { boundedIdentifierSchema, boundedEventContentStringSchema, boundedStringSchema, } from "./contract-limits.js";
 import { agentInteractiveDimensionSchema as interactiveDimensionSchema, sameAgentExactRun as sameExactRun, } from "./environment-interactive-shared.js";
 import { AgentExactRunControlRefSchema } from "./runtime-control.js";
 /**
@@ -348,7 +348,13 @@ const AgentInteractiveSessionPromptCommandMaterialSchema = z
     operationId: boundedIdentifierSchema,
     ref: AgentInteractiveSessionRefSchema,
     control: AgentInteractiveSessionControlClaimSchema,
-    prompt: boundedStringSchema.min(1),
+    // Content, not metadata: see environment-runtime.ts.
+    // Content, not metadata: see environment-runtime.ts. `boundedEventContentStringSchema` is a
+    // custom schema and carries no `.min`, so the non-empty requirement is kept as a refinement —
+    // an interactive prompt with nothing in it is still refused.
+    prompt: boundedEventContentStringSchema.refine((value) => value.length >= 1, {
+        message: "interactive prompt must not be empty",
+    }),
 })
     .superRefine((command, refinement) => {
     if (!agentInteractiveSessionControlClaimMatchesRef(command.ref, command.control)) {

package/dist/environment-runtime.d.ts

@@ -38,7 +38,7 @@ export interface AgentTurnInput {
     providerOptions?: Record<string, unknown>;
 }
 export declare const AgentTurnInputSchema: z.ZodObject<{
-    prompt: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodCustom<string, string>>;
     parts: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;
@@ -257,7 +257,7 @@ export interface AgentTurnResult {
 }
 /** Runtime validator for a provider turn returned from durable continuation. */
 export declare const AgentTurnResultSchema: z.ZodObject<{
-    text: z.ZodString;
+    text: z.ZodCustom<string, string>;
     success: z.ZodBoolean;
     error: z.ZodOptional<z.ZodString>;
     sessionId: z.ZodOptional<z.ZodString>;
@@ -413,7 +413,7 @@ export declare const AgentNativeContextContinuationResultSchema: z.ZodUnion<read
         }>;
     }, z.core.$strip>>;
     result: z.ZodObject<{
-        text: z.ZodString;
+        text: z.ZodCustom<string, string>;
         success: z.ZodBoolean;
         error: z.ZodOptional<z.ZodString>;
         sessionId: z.ZodOptional<z.ZodString>;

package/dist/environment-runtime.js

@@ -5,11 +5,16 @@ import { InteractionCapabilitiesSchema, RequestedInteractionsSchema } from "./in
 import { ContextTransferReceiptSchema, ContextTransferRequestSchema, NativeContextBoundaryProofSchema, NativeContextContinuationAcknowledgementSchema, NativeContextContinuationRequestSchema, nativeContextContinuationAcknowledgementMatches } from "./portable-context.js";
 import { AgentExactRunControlRefSchema, AgentRunControlRefSchema, CanonicalStreamEventSchema } from "./runtime-control.js";
 import { AgentProfileCapabilitiesSchema } from "./environment-profile-capabilities.js";
-import { boundedIdentifierSchema, boundedJsonRecordSchema, boundedJsonSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
+import { boundedEventContentJsonSchema, boundedEventContentRecordSchema, boundedEventContentStringSchema, boundedIdentifierSchema, boundedJsonRecordSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
 import { InputPartSchema } from "./portable-context-shared.js";
 import { deepFreeze } from "./deep-freeze.js";
 export const AgentTurnInputSchema = z.strictObject({
-    prompt: boundedStringSchema.optional(),
+    // A prompt is what the agent is asked to do, so it is CONTENT: its size is set by the work,
+    // not by the protocol. Held to the metadata bound it capped a manager's brief at 16,384
+    // characters, which refused a director handing a checker a 27 KB patch to re-verify a measured
+    // result (agent-sdk#313). Refusal is still right here — a silently shortened instruction is
+    // worse than none — so only the ceiling moves.
+    prompt: boundedEventContentStringSchema.optional(),
     parts: z.array(InputPartSchema).max(CONTRACT_MAX_ARRAY_LENGTH).optional(),
     sessionId: boundedIdentifierSchema.optional(),
     model: boundedIdentifierSchema.optional(),
@@ -37,16 +42,16 @@ const TokenUsageSchema = z.strictObject({
 });
 const AgentEnvironmentEventSchema = z.strictObject({
     type: boundedIdentifierSchema,
-    data: boundedJsonRecordSchema,
+    data: boundedEventContentRecordSchema,
     id: boundedIdentifierSchema.optional(),
     normalized: CanonicalStreamEventSchema.optional(),
     usage: TokenUsageSchema.optional(),
     usageMode: z.enum(["delta", "cumulative"]).optional(),
-    providerEvent: boundedJsonSchema.optional(),
+    providerEvent: boundedEventContentJsonSchema.optional(),
 });
 /** Runtime validator for a provider turn returned from durable continuation. */
 export const AgentTurnResultSchema = z.strictObject({
-    text: boundedStringSchema,
+    text: boundedEventContentStringSchema,
     success: z.boolean(),
     error: boundedStringSchema.optional(),
     sessionId: boundedIdentifierSchema.optional(),

package/dist/index.d.ts

@@ -40,5 +40,5 @@ export * from "./harness-capabilities.js";
 export * from "./profile-schema.js";
 export * from "./profile-security.js";
 export * from "./sandbox-size.js";
-export { CONTRACT_MAX_CONFIDENTIAL_ATTESTATION_QUOTE_LENGTH, } from "./contract-limits.js";
+export { CONTRACT_MAX_CONFIDENTIAL_ATTESTATION_QUOTE_LENGTH, CONTRACT_MAX_JSON_BYTES, boundedEventContentJsonSchema, boundedEventContentRecordSchema, boundedEventContentStringSchema, isBoundedEventContentJson, } from "./contract-limits.js";
 export { AgentEnvironmentEgressPolicySchema } from "./environment-requests.js";

package/dist/index.js

@@ -38,5 +38,5 @@ export * from "./harness-capabilities.js";
 export * from "./profile-schema.js";
 export * from "./profile-security.js";
 export * from "./sandbox-size.js";
-export { CONTRACT_MAX_CONFIDENTIAL_ATTESTATION_QUOTE_LENGTH, } from "./contract-limits.js";
+export { CONTRACT_MAX_CONFIDENTIAL_ATTESTATION_QUOTE_LENGTH, CONTRACT_MAX_JSON_BYTES, boundedEventContentJsonSchema, boundedEventContentRecordSchema, boundedEventContentStringSchema, isBoundedEventContentJson, } from "./contract-limits.js";
 export { AgentEnvironmentEgressPolicySchema } from "./environment-requests.js";

package/dist/portable-context-continuation.d.ts

@@ -62,7 +62,7 @@ export interface NativeContextContinuationTurn {
     providerOptions?: Record<string, unknown>;
 }
 export declare const NativeContextContinuationTurnSchema: z.ZodObject<{
-    prompt: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodCustom<string, string>>;
     parts: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
         text: z.ZodString;

package/dist/portable-context-continuation.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AgentExactRunControlRefSchema, } from "./runtime-control.js";
 import { idSchema, InputPartSchema, jsonRecordSchema, sha256DigestSchema, wireDigest } from "./portable-context-shared.js";
-import { boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
+import { boundedEventContentStringSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
 export const NativeContextBoundarySchema = z
     .discriminatedUnion("kind", [
     z.strictObject({ kind: z.literal("token"), token: idSchema }),
@@ -40,7 +40,8 @@ const NativeContextContinuationRequestMaterialSchema = z.strictObject({
     expectedBoundary: NativeContextBoundaryProofSchema,
 });
 export const NativeContextContinuationTurnSchema = z.strictObject({
-    prompt: boundedStringSchema.optional(),
+    // Content, not metadata: see environment-runtime.ts.
+    prompt: boundedEventContentStringSchema.optional(),
     parts: z.array(InputPartSchema).max(CONTRACT_MAX_ARRAY_LENGTH).optional(),
     model: idSchema.optional(),
     context: jsonRecordSchema.optional(),

package/dist/runtime-control.d.ts

@@ -164,7 +164,6 @@ export declare const AgentRunControlAcknowledgementSchema: z.ZodObject<{
     existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
 }, z.core.$strict>;
 export declare function agentRunControlAcknowledgementMatchesRequest(request: AgentRunControlRequest, acknowledgement: AgentRunControlAcknowledgement): boolean;
-/** Runtime validator for every member of the existing canonical event union. */
 export declare const CanonicalStreamEventSchema: z.ZodType<StreamEvent>;
 /** Ordered, replayable envelope around the existing canonical event union. */
 export interface RuntimeEventEnvelope {

package/dist/runtime-control.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { canonicalCandidateDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
-import { boundedIdentifierSchema, boundedJsonRecordSchema, boundedJsonSchema, boundedStringSchema, } from "./contract-limits.js";
+import { boundedEventContentJsonSchema, boundedEventContentRecordSchema, boundedEventContentStringSchema, boundedIdentifierSchema, boundedJsonRecordSchema, boundedStringSchema, isBoundedEventContentJson, } from "./contract-limits.js";
 import { ModelUsageSchema } from "./environment-observation.js";
 import { InteractionRequestSchema } from "./interaction.js";
 import { DurablePlanSchema } from "./plan.js";
@@ -213,20 +213,20 @@ const toolTimeSchema = z.strictObject({
 const toolStateSchema = z.discriminatedUnion("status", [
     z.strictObject({
         status: z.literal("pending"),
-        input: unknownRecordSchema,
-        raw: boundedStringSchema.optional(),
+        input: boundedEventContentRecordSchema,
+        raw: boundedEventContentStringSchema.optional(),
     }),
     z.strictObject({
         status: z.literal("running"),
-        input: unknownRecordSchema,
+        input: boundedEventContentRecordSchema,
         title: boundedStringSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: z.strictObject({ start: z.number().finite() }).optional(),
     }),
     z.strictObject({
         status: z.literal("completed"),
-        input: unknownRecordSchema,
-        output: boundedJsonSchema,
+        input: boundedEventContentRecordSchema,
+        output: boundedEventContentJsonSchema,
         title: boundedStringSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: z.strictObject({
@@ -236,15 +236,15 @@ const toolStateSchema = z.discriminatedUnion("status", [
     }),
     z.strictObject({
         status: z.enum(["error", "failed"]),
-        input: unknownRecordSchema,
+        input: boundedEventContentRecordSchema,
         error: boundedStringSchema.optional(),
-        output: boundedJsonSchema.optional(),
+        output: boundedEventContentJsonSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: toolTimeSchema.optional(),
     }),
 ]);
 const partSchema = z.discriminatedUnion("type", [
-    z.strictObject({ ...partBase, type: z.literal("text"), text: boundedStringSchema }),
+    z.strictObject({ ...partBase, type: z.literal("text"), text: boundedEventContentStringSchema }),
     z.strictObject({
         ...partBase,
         type: z.literal("tool"),
@@ -256,7 +256,7 @@ const partSchema = z.discriminatedUnion("type", [
     z.strictObject({
         ...partBase,
         type: z.literal("reasoning"),
-        text: boundedStringSchema,
+        text: boundedEventContentStringSchema,
     }),
     z.strictObject({
         ...partBase,
@@ -268,7 +268,8 @@ const partSchema = z.discriminatedUnion("type", [
     z.strictObject({
         ...partBase,
         type: z.literal("subtask"),
-        prompt: boundedStringSchema,
+        // Content, not metadata: see environment-runtime.ts.
+        prompt: boundedEventContentStringSchema,
         description: boundedStringSchema,
         agent: stableIdSchema,
     }),
@@ -338,11 +339,11 @@ const ChildTaskEventSchema = z
     }
 });
 /** Runtime validator for every member of the existing canonical event union. */
-export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
+const CanonicalStreamEventUnionSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("message.part.updated"),
         part: partSchema,
-        delta: boundedStringSchema.optional(),
+        delta: boundedEventContentStringSchema.optional(),
     }),
     z.strictObject({
         type: z.literal("tool-heartbeat"),
@@ -382,7 +383,7 @@ export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("raw"),
         backend: stableIdSchema,
-        event: boundedJsonSchema,
+        event: boundedEventContentJsonSchema,
     }),
     z.strictObject({
         type: z.literal("session.updated"),
@@ -408,6 +409,17 @@ export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
     }),
     ChildTaskEventSchema,
 ]);
+export const CanonicalStreamEventSchema = CanonicalStreamEventUnionSchema.superRefine((event, refinement) => {
+    // Zod retains explicitly supplied optional `undefined` fields, whereas a
+    // JSON event omits them. Canonical events use that wire-equivalent omission
+    // without making raw provider records accept undefined.
+    if (!isBoundedEventContentJson(event, { omitUndefinedObjectFields: true })) {
+        refinement.addIssue({
+            code: "custom",
+            message: "canonical stream event exceeds its serialized byte bound",
+        });
+    }
+});
 export const RuntimeEventEnvelopeSchema = z.strictObject({
     runId: stableIdSchema,
     eventId: stableIdSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-interface",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",