@tangle-network/agent-interface 0.45.0 → 0.46.0

package/dist/portable-context-plan-request.d.ts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type PortableContextDestination, type PortableContextPlan } from "./portable-context-plan.js";
+import { type PortableConversationContext } from "./portable-context-base.js";
+export interface PortableContextPlanRequestMaterial {
+    requestId: string;
+    source: PortableConversationContext;
+    destination: PortableContextDestination;
+    maxInputTokens?: number;
+}
+export declare function portableContextPlanRequestDigest(request: PortableContextPlanRequestMaterial): Sha256Digest;
+export interface PortableContextPlanRequest extends PortableContextPlanRequestMaterial {
+    requestId: string;
+    requestDigest: Sha256Digest;
+}
+export declare const PortableContextPlanRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    source: z.ZodObject<{
+        source: z.ZodObject<{
+            runId: z.ZodString;
+            messageId: z.ZodString;
+            provider: z.ZodString;
+            environmentId: z.ZodString;
+            sessionId: z.ZodString;
+            executionId: z.ZodString;
+            requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            branchId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        completeness: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            parts: z.ZodArray<z.ZodCustom<unknown, unknown>>;
+            timestamp: z.ZodISODateTime;
+            metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+        }, z.core.$strict>>;
+        attachments: z.ZodArray<z.ZodObject<{
+            messageId: z.ZodString;
+            partIndex: z.ZodNumber;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    destination: z.ZodObject<{
+        runner: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        executionId: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        profileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    maxInputTokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+interface PortableContextPlanResultBinding {
+    requestId: string;
+    requestDigest: Sha256Digest;
+}
+export type PortableContextPlanResult = (PortableContextPlanResultBinding & {
+    status: "ready";
+    plan: PortableContextPlan;
+}) | (PortableContextPlanResultBinding & {
+    status: "over_limit";
+    estimatedTokens?: number;
+    maxInputTokens: number;
+    suggestedBoundaryMessageId?: string;
+    message: string;
+}) | (PortableContextPlanResultBinding & {
+    status: "unsupported";
+    message: string;
+});
+export declare const PortableContextPlanResultSchema: z.ZodType<PortableContextPlanResult>;
+/** Cross-check a planner result against the exact request and token budget. */
+export declare function portableContextPlanResultMatchesRequest(request: PortableContextPlanRequest, result: PortableContextPlanResult): boolean;
+export {};

package/dist/portable-context-plan-request.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { idSchema, sha256DigestSchema, wireDigest } from "./portable-context-shared.js";
+import { boundedStringSchema } from "./contract-limits.js";
+import { PortableContextDestinationSchema, PortableContextPlanSchema } from "./portable-context-plan.js";
+import { PortableConversationContextSchema } from "./portable-context-base.js";
+const PortableContextPlanRequestMaterialSchema = z.strictObject({
+    requestId: idSchema,
+    source: PortableConversationContextSchema,
+    destination: PortableContextDestinationSchema,
+    maxInputTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+});
+export function portableContextPlanRequestDigest(request) {
+    const parsed = PortableContextPlanRequestMaterialSchema.parse(request);
+    return wireDigest({
+        requestId: parsed.requestId,
+        source: parsed.source,
+        destination: parsed.destination,
+        ...(parsed.maxInputTokens === undefined
+            ? {}
+            : { maxInputTokens: parsed.maxInputTokens }),
+    });
+}
+export const PortableContextPlanRequestSchema = z
+    .strictObject({
+    requestId: idSchema,
+    requestDigest: sha256DigestSchema,
+    source: PortableConversationContextSchema,
+    destination: PortableContextDestinationSchema,
+    maxInputTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional(),
+})
+    .superRefine((request, refinement) => {
+    if (request.requestDigest !==
+        portableContextPlanRequestDigest({
+            source: request.source,
+            destination: request.destination,
+            maxInputTokens: request.maxInputTokens,
+            requestId: request.requestId,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "portable context plan request digest does not match its content",
+        });
+    }
+});
+const portableContextPlanResultBinding = {
+    requestId: idSchema,
+    requestDigest: sha256DigestSchema,
+};
+export const PortableContextPlanResultSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        status: z.literal("ready"),
+        ...portableContextPlanResultBinding,
+        plan: PortableContextPlanSchema,
+    }),
+    z.strictObject({
+        status: z.literal("over_limit"),
+        ...portableContextPlanResultBinding,
+        estimatedTokens: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+        maxInputTokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+        suggestedBoundaryMessageId: idSchema.optional(),
+        message: boundedStringSchema.min(1),
+    }),
+    z.strictObject({
+        status: z.literal("unsupported"),
+        ...portableContextPlanResultBinding,
+        message: boundedStringSchema.min(1),
+    }),
+]);
+/** Cross-check a planner result against the exact request and token budget. */
+export function portableContextPlanResultMatchesRequest(request, result) {
+    const parsedRequest = PortableContextPlanRequestSchema.safeParse(request);
+    const parsedResult = PortableContextPlanResultSchema.safeParse(result);
+    if (!parsedRequest.success || !parsedResult.success)
+        return false;
+    const exactRequest = parsedRequest.data;
+    const exactResult = parsedResult.data;
+    if (exactResult.requestId !== exactRequest.requestId ||
+        exactResult.requestDigest !== exactRequest.requestDigest) {
+        return false;
+    }
+    if (exactResult.status === "ready") {
+        if (wireDigest(exactResult.plan.source) !== wireDigest(exactRequest.source) ||
+            wireDigest(exactResult.plan.destination) !==
+                wireDigest(exactRequest.destination)) {
+            return false;
+        }
+        if (exactRequest.maxInputTokens === undefined)
+            return true;
+        return (exactResult.plan.estimatedTokens !== undefined &&
+            exactResult.plan.estimatedTokens <= exactRequest.maxInputTokens);
+    }
+    if (exactResult.status === "over_limit") {
+        return (exactRequest.maxInputTokens !== undefined &&
+            exactResult.maxInputTokens === exactRequest.maxInputTokens &&
+            (exactResult.estimatedTokens === undefined ||
+                exactResult.estimatedTokens > exactRequest.maxInputTokens) &&
+            (exactResult.suggestedBoundaryMessageId === undefined ||
+                exactRequest.source.messages.some((message) => message.id === exactResult.suggestedBoundaryMessageId)));
+    }
+    return true;
+}

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

@@ -0,0 +1,229 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import type { InputPart } from "./parts.js";
+import { type PortableConversationContext } from "./portable-context-base.js";
+export interface PortableContextDestination {
+    runner: string;
+    provider: string;
+    environmentId: string;
+    sessionId: string;
+    runId: string;
+    executionId: string;
+    model?: string;
+    profileDigest: Sha256Digest;
+}
+export declare const PortableContextDestinationSchema: z.ZodObject<{
+    runner: z.ZodString;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    executionId: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    profileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export interface PortableContextPartPlan {
+    partIndex: number;
+    action: "include" | "transform" | "omit";
+    output?: InputPart;
+    reason?: string;
+}
+export declare const PortableContextPartPlanSchema: z.ZodObject<{
+    partIndex: z.ZodNumber;
+    action: z.ZodEnum<{
+        transform: "transform";
+        include: "include";
+        omit: "omit";
+    }>;
+    output: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        filename: z.ZodOptional<z.ZodString>;
+        mediaType: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface PortableContextMessagePlan {
+    messageId: string;
+    action: "include" | "omit";
+    parts: PortableContextPartPlan[];
+    reason?: string;
+}
+export declare const PortableContextMessagePlanSchema: z.ZodObject<{
+    messageId: z.ZodString;
+    action: z.ZodEnum<{
+        include: "include";
+        omit: "omit";
+    }>;
+    parts: z.ZodArray<z.ZodObject<{
+        partIndex: z.ZodNumber;
+        action: z.ZodEnum<{
+            transform: "transform";
+            include: "include";
+            omit: "omit";
+        }>;
+        output: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            filename: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+            content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            filename: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+            url: z.ZodOptional<z.ZodString>;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export interface PortableContextPlan {
+    planId: string;
+    /** Full immutable source so an executor can verify every decision itself. */
+    source: PortableConversationContext;
+    destination: PortableContextDestination;
+    messages: PortableContextMessagePlan[];
+    context: PortableConversationContext;
+    estimatedTokens?: number;
+    requiresAcceptance: boolean;
+    digest: Sha256Digest;
+}
+export type PortableContextPlanMaterial = Omit<PortableContextPlan, "digest">;
+export declare function portableContextPlanDigest(plan: PortableContextPlanMaterial): Sha256Digest;
+export declare const PortableContextPlanSchema: z.ZodObject<{
+    planId: z.ZodString;
+    source: z.ZodObject<{
+        source: z.ZodObject<{
+            runId: z.ZodString;
+            messageId: z.ZodString;
+            provider: z.ZodString;
+            environmentId: z.ZodString;
+            sessionId: z.ZodString;
+            executionId: z.ZodString;
+            requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            branchId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        completeness: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            parts: z.ZodArray<z.ZodCustom<unknown, unknown>>;
+            timestamp: z.ZodISODateTime;
+            metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+        }, z.core.$strict>>;
+        attachments: z.ZodArray<z.ZodObject<{
+            messageId: z.ZodString;
+            partIndex: z.ZodNumber;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    destination: z.ZodObject<{
+        runner: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        executionId: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        profileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    messages: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        action: z.ZodEnum<{
+            include: "include";
+            omit: "omit";
+        }>;
+        parts: z.ZodArray<z.ZodObject<{
+            partIndex: z.ZodNumber;
+            action: z.ZodEnum<{
+                transform: "transform";
+                include: "include";
+                omit: "omit";
+            }>;
+            output: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"file">;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+                content: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"image">;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "type">>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    context: z.ZodObject<{
+        source: z.ZodObject<{
+            runId: z.ZodString;
+            messageId: z.ZodString;
+            provider: z.ZodString;
+            environmentId: z.ZodString;
+            sessionId: z.ZodString;
+            executionId: z.ZodString;
+            requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            branchId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        completeness: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+        }>;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                user: "user";
+                assistant: "assistant";
+                system: "system";
+            }>;
+            parts: z.ZodArray<z.ZodCustom<unknown, unknown>>;
+            timestamp: z.ZodISODateTime;
+            metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+        }, z.core.$strict>>;
+        attachments: z.ZodArray<z.ZodObject<{
+            messageId: z.ZodString;
+            partIndex: z.ZodNumber;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+            name: z.ZodOptional<z.ZodString>;
+            mediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    estimatedTokens: z.ZodOptional<z.ZodNumber>;
+    requiresAcceptance: z.ZodBoolean;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;

package/dist/portable-context-plan.js

@@ -0,0 +1,241 @@
+import { z } from "zod";
+import { idSchema, InputPartSchema, sha256DigestSchema, sameStringSet, wireDigest, } from "./portable-context-shared.js";
+import { boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
+import { PortableConversationContextSchema } from "./portable-context-base.js";
+export const PortableContextDestinationSchema = z.strictObject({
+    runner: idSchema,
+    provider: idSchema,
+    environmentId: idSchema,
+    sessionId: idSchema,
+    runId: idSchema,
+    executionId: idSchema,
+    model: idSchema.optional(),
+    profileDigest: sha256DigestSchema,
+});
+export const PortableContextPartPlanSchema = z
+    .strictObject({
+    partIndex: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    action: z.enum(["include", "transform", "omit"]),
+    output: InputPartSchema.optional(),
+    reason: boundedStringSchema.min(1).optional(),
+})
+    .superRefine((part, refinement) => {
+    if (part.action === "transform" && part.output === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["output"],
+            message: "a transformed part must include its portable output",
+        });
+    }
+    if (part.action !== "transform" && part.output !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["output"],
+            message: "only a transformed part may include portable output",
+        });
+    }
+    if (part.action !== "include" && part.reason === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["reason"],
+            message: "a transformed or omitted part must include a reason",
+        });
+    }
+});
+export const PortableContextMessagePlanSchema = z
+    .strictObject({
+    messageId: idSchema,
+    action: z.enum(["include", "omit"]),
+    parts: z.array(PortableContextPartPlanSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+    reason: boundedStringSchema.min(1).optional(),
+})
+    .superRefine((message, refinement) => {
+    const indexes = message.parts.map((part) => part.partIndex);
+    if (new Set(indexes).size !== indexes.length) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["parts"],
+            message: "part indexes must be unique within a message plan",
+        });
+    }
+    if (message.action === "omit") {
+        if (message.reason === undefined) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["reason"],
+                message: "an omitted message must include a reason",
+            });
+        }
+        if (message.parts.some((part) => part.action !== "omit")) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["parts"],
+                message: "every part of an omitted message must be omitted",
+            });
+        }
+    }
+});
+const PortableContextPlanMaterialSchema = z.strictObject({
+    planId: idSchema,
+    source: PortableConversationContextSchema,
+    destination: PortableContextDestinationSchema,
+    messages: z.array(PortableContextMessagePlanSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+    context: PortableConversationContextSchema,
+    estimatedTokens: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+    requiresAcceptance: z.boolean(),
+});
+export function portableContextPlanDigest(plan) {
+    const parsed = PortableContextPlanMaterialSchema.parse(plan);
+    return wireDigest({
+        planId: parsed.planId,
+        source: parsed.source,
+        destination: parsed.destination,
+        messages: parsed.messages,
+        context: parsed.context,
+        ...(parsed.estimatedTokens === undefined
+            ? {}
+            : { estimatedTokens: parsed.estimatedTokens }),
+        requiresAcceptance: parsed.requiresAcceptance,
+    });
+}
+export const PortableContextPlanSchema = z
+    .strictObject({
+    planId: idSchema,
+    source: PortableConversationContextSchema,
+    destination: PortableContextDestinationSchema,
+    messages: z.array(PortableContextMessagePlanSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+    context: PortableConversationContextSchema,
+    estimatedTokens: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+    requiresAcceptance: z.boolean(),
+    digest: sha256DigestSchema,
+})
+    .superRefine((plan, refinement) => {
+    const messageIds = plan.messages.map((message) => message.messageId);
+    if (new Set(messageIds).size !== messageIds.length) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["messages"],
+            message: "message ids must be unique within a context plan",
+        });
+    }
+    const sourceMessageIds = plan.source.messages.map((message) => message.id);
+    if (!sameStringSet(messageIds, sourceMessageIds)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["messages"],
+            message: "a context plan must decide every source message exactly once",
+        });
+    }
+    if (wireDigest(plan.context.source) !== wireDigest(plan.source.source)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["context", "source"],
+            message: "output context source must match the immutable source",
+        });
+    }
+    const expectedMessages = [];
+    for (const sourceMessage of plan.source.messages) {
+        const messagePlan = plan.messages.find((candidate) => candidate.messageId === sourceMessage.id);
+        if (!messagePlan)
+            continue;
+        const expectedIndexes = sourceMessage.parts.map((_, index) => index);
+        const decidedIndexes = messagePlan.parts
+            .map((part) => part.partIndex)
+            .sort((left, right) => left - right);
+        if (JSON.stringify(expectedIndexes) !== JSON.stringify(decidedIndexes)) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["messages"],
+                message: `message "${sourceMessage.id}" must decide every source part exactly once`,
+            });
+            continue;
+        }
+        if (messagePlan.action === "omit")
+            continue;
+        const outputParts = [];
+        for (const partPlan of [...messagePlan.parts].sort((left, right) => left.partIndex - right.partIndex)) {
+            if (partPlan.action === "omit")
+                continue;
+            if (partPlan.action === "transform") {
+                if (partPlan.output)
+                    outputParts.push(partPlan.output);
+                continue;
+            }
+            const parsedPart = InputPartSchema.safeParse(sourceMessage.parts[partPlan.partIndex]);
+            if (!parsedPart.success) {
+                refinement.addIssue({
+                    code: "custom",
+                    path: ["messages"],
+                    message: `message "${sourceMessage.id}" part ${partPlan.partIndex} must be transformed or omitted`,
+                });
+                continue;
+            }
+            outputParts.push(parsedPart.data);
+        }
+        if (outputParts.length === 0) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["messages"],
+                message: `included message "${sourceMessage.id}" must retain at least one part`,
+            });
+        }
+        expectedMessages.push({ ...sourceMessage, parts: outputParts });
+    }
+    if (wireDigest(expectedMessages) !== wireDigest(plan.context.messages)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["context", "messages"],
+            message: "output messages do not exactly match the source decisions",
+        });
+    }
+    const expectedAttachments = plan.source.attachments.filter((attachment) => {
+        const message = plan.messages.find((candidate) => candidate.messageId === attachment.messageId);
+        const part = message?.parts.find((candidate) => candidate.partIndex === attachment.partIndex);
+        return message?.action === "include" && part?.action === "include";
+    });
+    if (wireDigest(expectedAttachments) !== wireDigest(plan.context.attachments)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["context", "attachments"],
+            message: "output attachments do not exactly match included source parts",
+        });
+    }
+    const changesContent = plan.messages.some((message) => message.action === "omit" ||
+        message.parts.some((part) => part.action !== "include"));
+    const requiresAcceptance = changesContent ||
+        plan.source.completeness === "partial" ||
+        plan.context.completeness === "partial";
+    if (plan.requiresAcceptance !== requiresAcceptance) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requiresAcceptance"],
+            message: "requiresAcceptance must be true when content changes or either context is partial",
+        });
+    }
+    const expectedCompleteness = changesContent || plan.source.completeness === "partial"
+        ? "partial"
+        : "complete";
+    if (plan.context.completeness !== expectedCompleteness) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["context", "completeness"],
+            message: `output context completeness must be ${expectedCompleteness}`,
+        });
+    }
+    if (plan.digest !==
+        portableContextPlanDigest({
+            planId: plan.planId,
+            source: plan.source,
+            destination: plan.destination,
+            messages: plan.messages,
+            context: plan.context,
+            estimatedTokens: plan.estimatedTokens,
+            requiresAcceptance: plan.requiresAcceptance,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["digest"],
+            message: "portable context plan digest does not match its content",
+        });
+    }
+});