@tangle-network/agent-interface 0.45.0 → 0.46.1

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { sha256DigestSchema } from "./agent-candidate-schema-common.js";
+export { sha256DigestSchema };
+export declare const idSchema: z.ZodString;
+export declare const jsonRecordSchema: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+export declare function wireDigest(value: unknown): Sha256Digest;
+export declare const InputPartSchema: 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">;
+export declare const BackendMessageSchema: 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>;
+export declare function sameStringSet(left: readonly string[], right: readonly string[]): boolean;

package/dist/portable-context-shared.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { canonicalCandidateDigest, sha256DigestSchema } from "./agent-candidate-schema-common.js";
+import { assertBoundedJson, assertBoundedSerializedJson, boundedIdentifierSchema, boundedJsonSchema, boundedJsonRecordSchema, boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH, isBoundedJsonMaterial, } from "./contract-limits.js";
+export { sha256DigestSchema };
+export const idSchema = boundedIdentifierSchema;
+export const jsonRecordSchema = boundedJsonRecordSchema;
+export function wireDigest(value) {
+    if (!isBoundedJsonMaterial(value)) {
+        throw new Error("operation material exceeds the contract bounds");
+    }
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw new Error("portable context material must be JSON serializable");
+    assertBoundedSerializedJson(serialized);
+    const normalized = JSON.parse(serialized);
+    assertBoundedJson(normalized);
+    return canonicalCandidateDigest(normalized);
+}
+export const InputPartSchema = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("text"), text: boundedStringSchema }),
+    z.strictObject({
+        type: z.literal("file"),
+        filename: boundedStringSchema.optional(),
+        mediaType: boundedStringSchema.optional(),
+        url: boundedStringSchema.optional(),
+        path: boundedStringSchema.optional(),
+        content: boundedStringSchema.optional(),
+    }),
+    z.strictObject({
+        type: z.literal("image"),
+        filename: boundedStringSchema.optional(),
+        mediaType: boundedStringSchema.optional(),
+        url: boundedStringSchema.optional(),
+        path: boundedStringSchema.optional(),
+    }),
+]);
+export const BackendMessageSchema = z.strictObject({
+    id: idSchema,
+    role: z.enum(["user", "assistant", "system"]),
+    parts: z.array(boundedJsonSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+    timestamp: z.iso.datetime().max(64),
+    metadata: jsonRecordSchema.optional(),
+});
+export function sameStringSet(left, right) {
+    return left.length === right.length && JSON.stringify([...left].sort()) === JSON.stringify([...right].sort());
+}

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

@@ -0,0 +1,319 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type PortableContextPlan } from "./portable-context-plan.js";
+export declare const ContextPlanAcceptanceSchema: z.ZodObject<{
+    planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    acceptedAt: z.ZodISODateTime;
+    acceptedBy: z.ZodEnum<{
+        policy: "policy";
+        user: "user";
+        system: "system";
+    }>;
+}, z.core.$strict>;
+export type ContextPlanAcceptance = z.infer<typeof ContextPlanAcceptanceSchema>;
+export interface ContextTransferRequestMaterial {
+    operationId: string;
+    plan: PortableContextPlan;
+    acceptance: ContextPlanAcceptance;
+}
+export declare function contextTransferRequestDigest(request: ContextTransferRequestMaterial): Sha256Digest;
+export declare const ContextTransferRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    plan: 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>;
+    acceptance: z.ZodObject<{
+        planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        acceptedAt: z.ZodISODateTime;
+        acceptedBy: z.ZodEnum<{
+            policy: "policy";
+            user: "user";
+            system: "system";
+        }>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ContextTransferRequest = z.infer<typeof ContextTransferRequestSchema>;
+export declare const ContextTransferReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"accepted" | "replayed">;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    contextDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    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>;
+    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>;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    executionId: z.ZodString;
+    sessionCreatedForOperationId: z.ZodString;
+    sessionCreatedAt: z.ZodISODateTime;
+    transferredMessageIds: z.ZodArray<z.ZodString>;
+    omittedMessageIds: z.ZodArray<z.ZodString>;
+    admittedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"accepted" | "replayed">;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    contextDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    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>;
+    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>;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    executionId: z.ZodString;
+    sessionCreatedForOperationId: z.ZodString;
+    sessionCreatedAt: z.ZodISODateTime;
+    transferredMessageIds: z.ZodArray<z.ZodString>;
+    omittedMessageIds: z.ZodArray<z.ZodString>;
+    admittedAt: z.ZodISODateTime;
+}, z.core.$strict>], "status">;
+export type ContextTransferReceipt = z.infer<typeof ContextTransferReceiptSchema>;
+/** Exact cross-check required before committing a transfer receipt. */
+export declare function contextTransferReceiptMatches(request: ContextTransferRequest, receipt: ContextTransferReceipt): boolean;
+export declare const ContextTransferResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"accepted" | "replayed">;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    contextDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    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>;
+    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>;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    executionId: z.ZodString;
+    sessionCreatedForOperationId: z.ZodString;
+    sessionCreatedAt: z.ZodISODateTime;
+    transferredMessageIds: z.ZodArray<z.ZodString>;
+    omittedMessageIds: z.ZodArray<z.ZodString>;
+    admittedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"accepted" | "replayed">;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    planDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    contextDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    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>;
+    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>;
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    executionId: z.ZodString;
+    sessionCreatedForOperationId: z.ZodString;
+    sessionCreatedAt: z.ZodISODateTime;
+    transferredMessageIds: z.ZodArray<z.ZodString>;
+    omittedMessageIds: z.ZodArray<z.ZodString>;
+    admittedAt: z.ZodISODateTime;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"conflict">;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    existingRequestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        transport_failure: "transport_failure";
+    }>;
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strict>], "status">;
+export type ContextTransferResult = z.infer<typeof ContextTransferResultSchema>;
+/** Bind every transfer outcome to the exact operation before acting on it. */
+export declare function contextTransferResultMatchesRequest(request: ContextTransferRequest, result: ContextTransferResult): boolean;

package/dist/portable-context-transfer.js

@@ -0,0 +1,206 @@
+import { z } from "zod";
+import { boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH, } from "./contract-limits.js";
+import { PortableContextSourceBoundarySchema, } from "./portable-context-base.js";
+import { PortableContextDestinationSchema, PortableContextPlanSchema, } from "./portable-context-plan.js";
+import { idSchema, sha256DigestSchema, wireDigest } from "./portable-context-shared.js";
+export const ContextPlanAcceptanceSchema = z.strictObject({
+    planDigest: sha256DigestSchema,
+    acceptedAt: z.iso.datetime().max(64),
+    acceptedBy: z.enum(["user", "policy", "system"]),
+});
+const ContextTransferRequestMaterialSchema = z.strictObject({
+    operationId: idSchema,
+    plan: PortableContextPlanSchema,
+    acceptance: ContextPlanAcceptanceSchema,
+});
+export function contextTransferRequestDigest(request) {
+    const parsed = ContextTransferRequestMaterialSchema.parse(request);
+    return wireDigest({
+        operationId: parsed.operationId,
+        planDigest: parsed.plan.digest,
+        acceptance: parsed.acceptance,
+    });
+}
+export const ContextTransferRequestSchema = z
+    .strictObject({
+    operationId: idSchema,
+    requestDigest: sha256DigestSchema,
+    plan: PortableContextPlanSchema,
+    acceptance: ContextPlanAcceptanceSchema,
+})
+    .superRefine((request, refinement) => {
+    if (request.acceptance.planDigest !== request.plan.digest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["acceptance", "planDigest"],
+            message: "accepted plan digest must match the executed plan",
+        });
+    }
+    if (request.requestDigest !==
+        contextTransferRequestDigest({
+            operationId: request.operationId,
+            plan: request.plan,
+            acceptance: request.acceptance,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "context transfer request digest does not match its content",
+        });
+    }
+    if (request.plan.requiresAcceptance &&
+        request.acceptance.acceptedBy === "system") {
+        refinement.addIssue({
+            code: "custom",
+            path: ["acceptance", "acceptedBy"],
+            message: "a transformed or partial plan requires user or policy acceptance",
+        });
+    }
+});
+function contextTransferReceiptVariant(status) {
+    return z
+        .strictObject({
+        status: z.literal(status),
+        operationId: idSchema,
+        requestDigest: sha256DigestSchema,
+        planDigest: sha256DigestSchema,
+        contextDigest: sha256DigestSchema,
+        source: PortableContextSourceBoundarySchema,
+        destination: PortableContextDestinationSchema,
+        provider: idSchema,
+        environmentId: idSchema,
+        sessionId: idSchema,
+        runId: idSchema,
+        executionId: idSchema,
+        sessionCreatedForOperationId: idSchema,
+        sessionCreatedAt: z.iso.datetime().max(64),
+        transferredMessageIds: z.array(idSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+        omittedMessageIds: z.array(idSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+        admittedAt: z.iso.datetime().max(64),
+    })
+        .superRefine((receipt, refinement) => {
+        const transferred = new Set(receipt.transferredMessageIds);
+        const omitted = new Set(receipt.omittedMessageIds);
+        if (transferred.size !== receipt.transferredMessageIds.length) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["transferredMessageIds"],
+                message: "transferred message ids must be unique",
+            });
+        }
+        if (omitted.size !== receipt.omittedMessageIds.length) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["omittedMessageIds"],
+                message: "omitted message ids must be unique",
+            });
+        }
+        if ([...transferred].some((messageId) => omitted.has(messageId))) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["omittedMessageIds"],
+                message: "a message cannot be both transferred and omitted",
+            });
+        }
+        if (Date.parse(receipt.sessionCreatedAt) > Date.parse(receipt.admittedAt)) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["sessionCreatedAt"],
+                message: "the destination session must exist before context admission",
+            });
+        }
+    });
+}
+export const ContextTransferReceiptSchema = z.discriminatedUnion("status", [
+    contextTransferReceiptVariant("accepted"),
+    contextTransferReceiptVariant("replayed"),
+]);
+/** Exact cross-check required before committing a transfer receipt. */
+export function contextTransferReceiptMatches(request, receipt) {
+    const parsedRequest = ContextTransferRequestSchema.safeParse(request);
+    const parsedReceipt = ContextTransferReceiptSchema.safeParse(receipt);
+    if (!parsedRequest.success || !parsedReceipt.success)
+        return false;
+    const exactRequest = parsedRequest.data;
+    const exactReceipt = parsedReceipt.data;
+    const included = exactRequest.plan.messages
+        .filter((message) => message.action === "include")
+        .map((message) => message.messageId)
+        .sort();
+    const omitted = exactRequest.plan.messages
+        .filter((message) => message.action === "omit")
+        .map((message) => message.messageId)
+        .sort();
+    const source = exactRequest.plan.source;
+    const destination = exactRequest.plan.destination;
+    const createdAt = Date.parse(exactReceipt.sessionCreatedAt);
+    const acceptedAt = Date.parse(exactRequest.acceptance.acceptedAt);
+    const admittedAt = Date.parse(exactReceipt.admittedAt);
+    return (createdAt >= acceptedAt &&
+        createdAt <= admittedAt &&
+        exactReceipt.operationId === exactRequest.operationId &&
+        exactReceipt.requestDigest === exactRequest.requestDigest &&
+        exactReceipt.planDigest === exactRequest.plan.digest &&
+        exactReceipt.contextDigest === exactRequest.plan.context.digest &&
+        wireDigest(exactReceipt.source) === wireDigest(source.source) &&
+        wireDigest(exactReceipt.destination) === wireDigest(destination) &&
+        exactReceipt.provider === destination.provider &&
+        exactReceipt.environmentId === destination.environmentId &&
+        exactReceipt.sessionId === destination.sessionId &&
+        exactReceipt.runId === destination.runId &&
+        exactReceipt.executionId === destination.executionId &&
+        exactReceipt.sessionCreatedForOperationId === exactRequest.operationId &&
+        exactReceipt.environmentId !== source.source.environmentId &&
+        exactReceipt.sessionId !== source.source.sessionId &&
+        exactReceipt.runId !== source.source.runId &&
+        exactReceipt.executionId !== source.source.executionId &&
+        JSON.stringify([...exactReceipt.transferredMessageIds].sort()) ===
+            JSON.stringify(included) &&
+        JSON.stringify([...exactReceipt.omittedMessageIds].sort()) ===
+            JSON.stringify(omitted));
+}
+export const ContextTransferResultSchema = z
+    .discriminatedUnion("status", [
+    contextTransferReceiptVariant("accepted"),
+    contextTransferReceiptVariant("replayed"),
+    z.strictObject({
+        status: z.literal("conflict"),
+        operationId: idSchema,
+        requestDigest: sha256DigestSchema,
+        existingRequestDigest: sha256DigestSchema,
+    }),
+    z.strictObject({
+        status: z.enum(["unknown", "transport_failure"]),
+        operationId: idSchema,
+        requestDigest: sha256DigestSchema,
+        message: boundedStringSchema.min(1),
+        retryable: z.boolean(),
+    }),
+])
+    .superRefine((result, refinement) => {
+    if (result.status === "conflict" &&
+        result.existingRequestDigest === result.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a transfer conflict must identify a different request",
+        });
+    }
+});
+/** Bind every transfer outcome to the exact operation before acting on it. */
+export function contextTransferResultMatchesRequest(request, result) {
+    const parsedRequest = ContextTransferRequestSchema.safeParse(request);
+    const parsedResult = ContextTransferResultSchema.safeParse(result);
+    if (!parsedRequest.success || !parsedResult.success)
+        return false;
+    const exactRequest = parsedRequest.data;
+    const exactResult = parsedResult.data;
+    if (exactResult.operationId !== exactRequest.operationId ||
+        exactResult.requestDigest !== exactRequest.requestDigest) {
+        return false;
+    }
+    if (exactResult.status === "accepted" || exactResult.status === "replayed") {
+        return contextTransferReceiptMatches(exactRequest, exactResult);
+    }
+    return true;
+}