@tangle-network/agent-interface 2.5.0 → 2.6.1

package/dist/agent-candidate-lineage-schema.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { AgentCandidateLineage } from "./agent-candidate.js";
 export declare const agentCandidateKnowledgeSchema: z.ZodObject<{
     candidate: z.ZodObject<{
         kind: z.ZodLiteral<"knowledge-improvement-candidate">;
@@ -124,9 +125,19 @@ export declare const agentCandidateMemoryPolicySchema: z.ZodDiscriminatedUnion<[
         byteLength: z.ZodNumber;
     }, z.core.$strict>>;
 }, z.core.$strict>], "mode">;
+/**
+ * Sources whose candidate was PRODUCED from a parent rather than supplied whole.
+ *
+ * One list, read by the lineage schema and by every experiment schema that gates on it. Three
+ * call sites branched on `optimizer || compound` independently, so adding a fourth generated
+ * source silently exempted it from the "name your baseline" rule in two of them.
+ */
+export declare const generatedCandidateSources: readonly ["optimizer", "compound", "frontier-author"];
+export declare function isGeneratedCandidateSource(source: AgentCandidateLineage["source"]): boolean;
 export declare const agentCandidateLineageSchema: z.ZodObject<{
     source: z.ZodEnum<{
         compound: "compound";
+        "frontier-author": "frontier-author";
         human: "human";
         import: "import";
         optimizer: "optimizer";

package/dist/agent-candidate-lineage-schema.js

@@ -39,9 +39,30 @@ export const agentCandidateMemoryPolicySchema = z.discriminatedUnion("mode", [
     })
         .strict(),
 ]);
+/**
+ * Sources whose candidate was PRODUCED from a parent rather than supplied whole.
+ *
+ * One list, read by the lineage schema and by every experiment schema that gates on it. Three
+ * call sites branched on `optimizer || compound` independently, so adding a fourth generated
+ * source silently exempted it from the "name your baseline" rule in two of them.
+ */
+export const generatedCandidateSources = [
+    "optimizer",
+    "compound",
+    "frontier-author",
+];
+export function isGeneratedCandidateSource(source) {
+    return generatedCandidateSources.includes(source);
+}
 export const agentCandidateLineageSchema = z
     .object({
-    source: z.enum(["optimizer", "human", "import", "compound"]),
+    source: z.enum([
+        "optimizer",
+        "human",
+        "import",
+        "compound",
+        "frontier-author",
+    ]),
     parentDigests: z.array(sha256DigestSchema).optional(),
     runIds: z.array(z.string().min(1)).optional(),
     profileDiffIds: z.array(z.string().min(1)).optional(),
@@ -62,7 +83,9 @@ export const agentCandidateLineageSchema = z
             message: "compound candidates must name at least two distinct parents",
         });
     }
-    if (lineage.source === "optimizer" || lineage.source === "compound") {
+    // Every generated lineage names what it came from and the run that produced
+    // it, whoever generated it.
+    if (isGeneratedCandidateSource(lineage.source)) {
         if ((lineage.parentDigests?.length ?? 0) === 0) {
             ctx.addIssue({
                 code: "custom",
@@ -77,6 +100,13 @@ export const agentCandidateLineageSchema = z
                 message: "generated candidates must name their producing run",
             });
         }
+    }
+    // A development split exists only when an offline search produced the
+    // candidate. An agent that authors a profile inside a run has no held-out
+    // set to pin, so requiring one would force a fabricated digest into the
+    // evidence record. This branch is deliberately NOT the generated-source
+    // list above.
+    if (lineage.source === "optimizer" || lineage.source === "compound") {
         if (lineage.developmentSplitDigest === undefined) {
             ctx.addIssue({
                 code: "custom",

package/dist/agent-candidate-promotion-schema.d.ts

@@ -1680,6 +1680,7 @@ export declare const agentCandidateExperimentSchema: z.ZodObject<{
     candidateLineage: z.ZodObject<{
         source: z.ZodEnum<{
             compound: "compound";
+            "frontier-author": "frontier-author";
             human: "human";
             import: "import";
             optimizer: "optimizer";
@@ -5277,6 +5278,7 @@ export declare const agentImprovementMeasuredComparisonSchema: z.ZodObject<{
         candidateLineage: z.ZodObject<{
             source: z.ZodEnum<{
                 compound: "compound";
+                "frontier-author": "frontier-author";
                 human: "human";
                 import: "import";
                 optimizer: "optimizer";
@@ -10304,6 +10306,7 @@ export declare const agentImprovementProposalSchema: z.ZodObject<{
             candidateLineage: z.ZodObject<{
                 source: z.ZodEnum<{
                     compound: "compound";
+                    "frontier-author": "frontier-author";
                     human: "human";
                     import: "import";
                     optimizer: "optimizer";
@@ -13666,6 +13669,7 @@ export declare const agentImprovementProposalSchema: z.ZodObject<{
             candidateLineage: z.ZodObject<{
                 source: z.ZodEnum<{
                     compound: "compound";
+                    "frontier-author": "frontier-author";
                     human: "human";
                     import: "import";
                     optimizer: "optimizer";

package/dist/agent-candidate-promotion-schema.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AGENT_IMPROVEMENT_SURFACES } from "./agent-candidate.js";
 import { agentCandidateBundleSchema } from "./agent-candidate-schema.js";
-import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
+import { agentCandidateLineageSchema, isGeneratedCandidateSource, } from "./agent-candidate-lineage-schema.js";
 import { agentCandidateBenchmarkSuiteInputsSchema } from "./agent-candidate-task-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
@@ -23,7 +23,7 @@ export const agentCandidateExperimentSchema = z
     .strict()
     .superRefine((experiment, ctx) => {
     const source = experiment.candidateLineage.source;
-    if ((source === "optimizer" || source === "compound") &&
+    if (isGeneratedCandidateSource(source) &&
         !experiment.candidateLineage.parentDigests?.includes(experiment.baseline.digest)) {
         ctx.addIssue({
             code: "custom",

package/dist/agent-candidate.d.ts

@@ -288,7 +288,20 @@ export interface AgentCandidateFixedSpend {
 }
 /** Evidence and ancestry that produced the immutable candidate. */
 export interface AgentCandidateLineage {
-    source: "optimizer" | "human" | "import" | "compound";
+    /**
+     * Who produced this candidate.
+     *
+     * `frontier-author` is an agent that wrote another agent's profile — the same
+     * member {@link AgentProfileDiff}`.source.kind` already carries, so the two
+     * enums name one actor with one word. It covers a supervising agent authoring
+     * a child's full `AgentProfile` from inside a run, which `spawn_worker`
+     * exposes and a `driver` role promotes to a sub-supervisor.
+     *
+     * It carries `optimizer`'s parent and run requirements and not its
+     * `developmentSplitDigest`: there is no held-out split and no offline search
+     * behind a profile an agent wrote while working.
+     */
+    source: "optimizer" | "human" | "import" | "compound" | "frontier-author";
     parentDigests?: Sha256Digest[];
     runIds?: string[];
     profileDiffIds?: string[];

package/dist/agent-profile-improvement-schema.d.ts

@@ -236,6 +236,7 @@ export declare const agentProfileImprovementExperimentSchema: z.ZodObject<{
     candidateLineage: z.ZodObject<{
         source: z.ZodEnum<{
             compound: "compound";
+            "frontier-author": "frontier-author";
             human: "human";
             import: "import";
             optimizer: "optimizer";
@@ -768,6 +769,7 @@ export declare const agentProfileImprovementMeasuredComparisonSchema: z.ZodObjec
         candidateLineage: z.ZodObject<{
             source: z.ZodEnum<{
                 compound: "compound";
+                "frontier-author": "frontier-author";
                 human: "human";
                 import: "import";
                 optimizer: "optimizer";

package/dist/agent-profile-improvement-schema.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { changedAgentProfileAxes } from "./profile-diff.js";
-import { agentCandidateLineageSchema } from "./agent-candidate-lineage-schema.js";
+import { agentCandidateLineageSchema, isGeneratedCandidateSource, } from "./agent-candidate-lineage-schema.js";
 import { canonicalCandidateDigest, isCanonicalJsonValue, omitTopLevelDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
 import { refineAgentExecutionWithinLimits } from "./agent-execution-limits.js";
 import { agentCandidateBenchmarkGraderIdentitySchema, agentCandidateExecutionLimitsSchema, agentCandidateResolvedModelSchema, } from "./agent-candidate-execution-plan-schema.js";
@@ -189,7 +189,7 @@ export const agentProfileImprovementExperimentSchema = z
         });
     }
     const source = experiment.candidateLineage.source;
-    if ((source === "optimizer" || source === "compound") &&
+    if (isGeneratedCandidateSource(source) &&
         !experiment.candidateLineage.parentDigests?.includes(experiment.baseline.stateDigest)) {
         ctx.addIssue({
             code: "custom",

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-runtime.d.ts

@@ -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,7 +5,7 @@ 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({
@@ -37,16 +37,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/profile-diff.d.ts

@@ -49,6 +49,11 @@ export interface AgentProfileDiff {
     description?: string;
     rationale?: string;
     source?: {
+        /**
+         * Who produced this change. `frontier-author` is an agent that wrote it —
+         * the same member {@link AgentCandidateLineage}`.source` carries, so the two
+         * enums name one actor with one word.
+         */
         kind: "trace" | "frontier-author" | "human" | "optimizer" | "compound";
         artifacts?: readonly string[];
         notes?: readonly string[];

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,
@@ -338,11 +338,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 +382,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 +408,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.5.0",
+  "version": "2.6.1",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",