@tangle-network/agent-interface 0.44.0 → 0.46.0

package/dist/parts.d.ts

@@ -0,0 +1,104 @@
+/** Base fields shared by all parts. */
+export type PartBase = {
+    id: string;
+    sessionID: string;
+    messageID: string;
+};
+export type TextPart = PartBase & {
+    type: "text";
+    text: string;
+};
+export type ToolStatePending = {
+    status: "pending";
+    input: Record<string, unknown>;
+    raw?: string;
+};
+export type ToolStateRunning = {
+    status: "running";
+    input: Record<string, unknown>;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    time?: {
+        start: number;
+    };
+};
+export type ToolStateCompleted = {
+    status: "completed";
+    input: Record<string, unknown>;
+    output: unknown;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    time?: {
+        start: number;
+        end: number;
+    };
+};
+export type ToolStateError = {
+    status: "error" | "failed";
+    input: Record<string, unknown>;
+    error?: string;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+    time?: {
+        start: number;
+        end?: number;
+    };
+};
+export type ToolState = ToolStatePending | ToolStateRunning | ToolStateCompleted | ToolStateError;
+export type ToolPart = PartBase & {
+    type: "tool";
+    callID?: string;
+    tool: string;
+    state: ToolState;
+    metadata?: Record<string, unknown>;
+};
+export type ReasoningPart = PartBase & {
+    type: "reasoning";
+    text: string;
+};
+export type FilePart = PartBase & {
+    type: "file";
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+};
+export type SubtaskPart = PartBase & {
+    type: "subtask";
+    prompt: string;
+    description: string;
+    agent: string;
+};
+export type Part = TextPart | ToolPart | ReasoningPart | FilePart | SubtaskPart;
+export declare function isTextPart(part: Part): part is TextPart;
+export declare function isToolPart(part: Part): part is ToolPart;
+export declare function isReasoningPart(part: Part): part is ReasoningPart;
+export declare function isFilePart(part: Part): part is FilePart;
+export declare function isSubtaskPart(part: Part): part is SubtaskPart;
+export type InputTextPart = {
+    type: "text";
+    text: string;
+};
+export type InputFilePart = {
+    type: "file";
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+    content?: string;
+};
+export type InputImagePart = {
+    type: "image";
+    filename?: string;
+    mediaType?: string;
+    url?: string;
+    path?: string;
+};
+export type InputPart = InputTextPart | InputFilePart | InputImagePart;
+export declare function isInputTextPart(part: InputPart): part is InputTextPart;
+export declare function isInputFilePart(part: InputPart): part is InputFilePart;
+export declare function isInputImagePart(part: InputPart): part is InputImagePart;
+export declare function normalizeInputParts(input: {
+    message?: string;
+    parts?: InputPart[];
+}): InputPart[];
+export declare function renderInputPartsAsText(parts: InputPart[]): string;

package/dist/parts.js

@@ -0,0 +1,55 @@
+export function isTextPart(part) {
+    return part.type === "text";
+}
+export function isToolPart(part) {
+    return part.type === "tool";
+}
+export function isReasoningPart(part) {
+    return part.type === "reasoning";
+}
+export function isFilePart(part) {
+    return part.type === "file";
+}
+export function isSubtaskPart(part) {
+    return part.type === "subtask";
+}
+export function isInputTextPart(part) {
+    return part.type === "text";
+}
+export function isInputFilePart(part) {
+    return part.type === "file";
+}
+export function isInputImagePart(part) {
+    return part.type === "image";
+}
+export function normalizeInputParts(input) {
+    if (Array.isArray(input.parts) && input.parts.length > 0) {
+        return input.parts;
+    }
+    if (typeof input.message === "string" && input.message.length > 0) {
+        return [{ type: "text", text: input.message }];
+    }
+    return [];
+}
+export function renderInputPartsAsText(parts) {
+    const textParts = [];
+    const attachmentRefs = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            if (part.text)
+                textParts.push(part.text);
+            continue;
+        }
+        const label = part.path ||
+            part.filename ||
+            part.url ||
+            (part.type === "image" ? "image attachment" : "file attachment");
+        attachmentRefs.push(`[${part.type === "image" ? "Image" : "File"}: ${label}]`);
+    }
+    if (attachmentRefs.length === 0) {
+        return textParts.join("\n\n").trim();
+    }
+    const text = textParts.join("\n\n").trim();
+    const attachmentBlock = `Attached files:\n${attachmentRefs.join("\n")}`;
+    return text ? `${text}\n\n${attachmentBlock}` : attachmentBlock;
+}

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

@@ -0,0 +1,82 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import type { BackendMessage } from "./backend-message.js";
+export interface PortableContextSourceBoundary {
+    runId: string;
+    messageId: string;
+    provider: string;
+    environmentId: string;
+    sessionId: string;
+    executionId: string;
+    requestDigest: Sha256Digest;
+    branchId?: string;
+}
+export declare const PortableContextSourceBoundarySchema: 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>;
+export interface PortableContextAttachmentRef {
+    messageId: string;
+    partIndex: number;
+    digest: Sha256Digest;
+    name?: string;
+    mediaType?: string;
+}
+export declare const PortableContextAttachmentRefSchema: 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>;
+export interface PortableConversationContext {
+    source: PortableContextSourceBoundary;
+    completeness: "complete" | "partial";
+    messages: BackendMessage[];
+    attachments: PortableContextAttachmentRef[];
+    digest: Sha256Digest;
+}
+type PortableConversationContextMaterial = Omit<PortableConversationContext, "digest">;
+export declare function portableConversationContextDigest(context: PortableConversationContextMaterial): Sha256Digest;
+export declare const PortableConversationContextSchema: 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>;
+export {};

package/dist/portable-context-base.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { BackendMessageSchema, idSchema, sha256DigestSchema, wireDigest, } from "./portable-context-shared.js";
+export const PortableContextSourceBoundarySchema = z.strictObject({
+    runId: idSchema,
+    messageId: idSchema,
+    provider: idSchema,
+    environmentId: idSchema,
+    sessionId: idSchema,
+    executionId: idSchema,
+    requestDigest: sha256DigestSchema,
+    branchId: idSchema.optional(),
+});
+export const PortableContextAttachmentRefSchema = z.strictObject({
+    messageId: idSchema,
+    partIndex: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    digest: sha256DigestSchema,
+    name: idSchema.optional(),
+    mediaType: idSchema.optional(),
+});
+export function portableConversationContextDigest(context) {
+    return wireDigest(context);
+}
+export const PortableConversationContextSchema = z
+    .strictObject({
+    source: PortableContextSourceBoundarySchema,
+    completeness: z.enum(["complete", "partial"]),
+    messages: z.array(BackendMessageSchema).max(1_024),
+    attachments: z.array(PortableContextAttachmentRefSchema).max(1_024),
+    digest: sha256DigestSchema,
+})
+    .superRefine((context, refinement) => {
+    const messageIds = context.messages.map((message) => message.id);
+    if (new Set(messageIds).size !== messageIds.length) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["messages"],
+            message: "portable context message ids must be unique",
+        });
+    }
+    for (const attachment of context.attachments) {
+        const message = context.messages.find((candidate) => candidate.id === attachment.messageId);
+        if (!message || attachment.partIndex >= message.parts.length) {
+            refinement.addIssue({
+                code: "custom",
+                path: ["attachments"],
+                message: "attachment must reference a part in the portable context",
+            });
+        }
+    }
+    if (context.digest !==
+        portableConversationContextDigest({
+            source: context.source,
+            completeness: context.completeness,
+            messages: context.messages,
+            attachments: context.attachments,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["digest"],
+            message: "portable context digest does not match its content",
+        });
+    }
+});

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

@@ -0,0 +1,168 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type AgentExactRunControlRef } from "./runtime-control.js";
+export declare const NativeContextBoundarySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"token">;
+    token: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"revision">;
+    revision: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"digest">;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"messages">;
+    messageIds: z.ZodArray<z.ZodString>;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>], "kind">;
+export type NativeContextBoundary = z.infer<typeof NativeContextBoundarySchema>;
+export declare const NativeContextBoundaryProofSchema: z.ZodObject<{
+    runId: 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>>;
+    boundary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"token">;
+        token: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"revision">;
+        revision: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"digest">;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"messages">;
+        messageIds: z.ZodArray<z.ZodString>;
+        digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>], "kind">;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type NativeContextBoundaryProof = z.infer<typeof NativeContextBoundaryProofSchema>;
+export interface NativeContextContinuationRequest {
+    operationId: string;
+    requestDigest: Sha256Digest;
+    turnDigest: Sha256Digest;
+    run: AgentExactRunControlRef;
+    expectedBoundary: NativeContextBoundaryProof;
+}
+export interface NativeContextContinuationRequestMaterial {
+    operationId: string;
+    turnDigest: Sha256Digest;
+    run: AgentExactRunControlRef;
+    expectedBoundary: NativeContextBoundaryProof;
+}
+/** JSON-stable user turn admitted by a native same-session continuation. */
+export interface NativeContextContinuationTurn {
+    prompt?: string;
+    parts?: import("./parts.js").InputPart[];
+    model?: string;
+    context?: Record<string, unknown>;
+    providerOptions?: Record<string, unknown>;
+}
+export declare const NativeContextContinuationTurnSchema: z.ZodObject<{
+    prompt: z.ZodOptional<z.ZodString>;
+    parts: z.ZodOptional<z.ZodArray<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">>>;
+    model: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    providerOptions: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
+/** Bind retry identity to the exact new user turn. */
+export declare function nativeContextContinuationTurnDigest(turn: NativeContextContinuationTurn): Sha256Digest;
+export declare function nativeContextContinuationRequestDigest(request: NativeContextContinuationRequestMaterial): Sha256Digest;
+export declare const NativeContextContinuationRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    turnDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    run: z.ZodObject<{
+        runId: 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>>;
+    }, z.core.$strict>;
+    expectedBoundary: z.ZodObject<{
+        runId: 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>>;
+        boundary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"token">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"revision">;
+            revision: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"digest">;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"messages">;
+            messageIds: z.ZodArray<z.ZodString>;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>], "kind">;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const NativeContextContinuationAcknowledgementSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    status: z.ZodEnum<{
+        conflict: "conflict";
+        accepted: "accepted";
+        transport_failure: "transport_failure";
+        replayed: "replayed";
+        boundary_mismatch: "boundary_mismatch";
+        unverified: "unverified";
+        unknown_session: "unknown_session";
+    }>;
+    historyMessagesSent: z.ZodNumber;
+    existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+    actualBoundary: z.ZodOptional<z.ZodObject<{
+        runId: 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>>;
+        boundary: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"token">;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"revision">;
+            revision: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"digest">;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"messages">;
+            messageIds: z.ZodArray<z.ZodString>;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>], "kind">;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    message: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type NativeContextContinuationAcknowledgement = z.infer<typeof NativeContextContinuationAcknowledgementSchema>;
+/** Exact cross-check required before accepting a native continuation result. */
+export declare function nativeContextContinuationAcknowledgementMatches(request: NativeContextContinuationRequest, acknowledgement: NativeContextContinuationAcknowledgement): boolean;

package/dist/portable-context-continuation.js

@@ -0,0 +1,194 @@
+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";
+export const NativeContextBoundarySchema = z
+    .discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("token"), token: idSchema }),
+    z.strictObject({ kind: z.literal("revision"), revision: idSchema }),
+    z.strictObject({ kind: z.literal("digest"), digest: sha256DigestSchema }),
+    z.strictObject({
+        kind: z.literal("messages"),
+        messageIds: z.array(idSchema).max(CONTRACT_MAX_ARRAY_LENGTH),
+        digest: sha256DigestSchema,
+    }),
+])
+    .superRefine((boundary, refinement) => {
+    if (boundary.kind === "messages" &&
+        new Set(boundary.messageIds).size !== boundary.messageIds.length) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["messageIds"],
+            message: "native context boundary message ids must be unique",
+        });
+    }
+});
+export const NativeContextBoundaryProofSchema = z.strictObject({
+    runId: idSchema,
+    provider: idSchema,
+    environmentId: idSchema,
+    sessionId: idSchema,
+    executionId: idSchema,
+    requestDigest: sha256DigestSchema,
+    boundary: NativeContextBoundarySchema,
+    observedAt: z.iso.datetime().max(64),
+});
+const NativeContextContinuationRequestMaterialSchema = z.strictObject({
+    operationId: idSchema,
+    turnDigest: sha256DigestSchema,
+    run: AgentExactRunControlRefSchema,
+    expectedBoundary: NativeContextBoundaryProofSchema,
+});
+export const NativeContextContinuationTurnSchema = z.strictObject({
+    prompt: boundedStringSchema.optional(),
+    parts: z.array(InputPartSchema).max(CONTRACT_MAX_ARRAY_LENGTH).optional(),
+    model: idSchema.optional(),
+    context: jsonRecordSchema.optional(),
+    providerOptions: jsonRecordSchema.optional(),
+});
+/** Bind retry identity to the exact new user turn. */
+export function nativeContextContinuationTurnDigest(turn) {
+    return wireDigest(NativeContextContinuationTurnSchema.parse(turn));
+}
+export function nativeContextContinuationRequestDigest(request) {
+    const parsed = NativeContextContinuationRequestMaterialSchema.parse(request);
+    return wireDigest({
+        turnDigest: parsed.turnDigest,
+        operationId: parsed.operationId,
+        run: parsed.run,
+        expectedBoundary: parsed.expectedBoundary,
+    });
+}
+export const NativeContextContinuationRequestSchema = z
+    .strictObject({
+    operationId: idSchema,
+    requestDigest: sha256DigestSchema,
+    turnDigest: sha256DigestSchema,
+    run: AgentExactRunControlRefSchema,
+    expectedBoundary: NativeContextBoundaryProofSchema,
+})
+    .superRefine((request, refinement) => {
+    const proof = request.expectedBoundary;
+    if (request.run.runId !== proof.runId ||
+        request.run.provider !== proof.provider ||
+        request.run.environmentId !== proof.environmentId ||
+        request.run.sessionId !== proof.sessionId ||
+        request.run.executionId !== proof.executionId ||
+        request.run.requestDigest !== proof.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["expectedBoundary"],
+            message: "boundary proof must match the continued run",
+        });
+    }
+    const { requestDigest: _requestDigest, ...material } = request;
+    if (request.requestDigest !== nativeContextContinuationRequestDigest(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "native continuation request digest does not match its content",
+        });
+    }
+});
+export const NativeContextContinuationAcknowledgementSchema = z
+    .strictObject({
+    operationId: idSchema,
+    requestDigest: sha256DigestSchema,
+    status: z.enum([
+        "accepted",
+        "replayed",
+        "conflict",
+        "boundary_mismatch",
+        "unverified",
+        "unknown_session",
+        "transport_failure",
+    ]),
+    historyMessagesSent: z.number().int().nonnegative().max(CONTRACT_MAX_ARRAY_LENGTH),
+    existingRequestDigest: sha256DigestSchema.optional(),
+    actualBoundary: NativeContextBoundaryProofSchema.optional(),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+})
+    .superRefine((acknowledgement, refinement) => {
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a continuation conflict must include the existing digest",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === acknowledgement.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a continuation conflict must identify a different request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only a continuation conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.status === "transport_failure" &&
+        acknowledgement.message === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["message"],
+            message: "a continuation transport failure must include a message",
+        });
+    }
+    if (acknowledgement.status === "transport_failure" &&
+        acknowledgement.retryable === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "a continuation transport failure must state whether retry is safe",
+        });
+    }
+    if (["accepted", "replayed", "boundary_mismatch"].includes(acknowledgement.status) &&
+        acknowledgement.actualBoundary === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["actualBoundary"],
+            message: `${acknowledgement.status} must include the observed boundary`,
+        });
+    }
+});
+/** Exact cross-check required before accepting a native continuation result. */
+export function nativeContextContinuationAcknowledgementMatches(request, acknowledgement) {
+    const parsedRequest = NativeContextContinuationRequestSchema.safeParse(request);
+    const parsedAcknowledgement = NativeContextContinuationAcknowledgementSchema.safeParse(acknowledgement);
+    if (!parsedRequest.success || !parsedAcknowledgement.success)
+        return false;
+    const exactRequest = parsedRequest.data;
+    const exactAcknowledgement = parsedAcknowledgement.data;
+    if (exactAcknowledgement.operationId !== exactRequest.operationId ||
+        exactAcknowledgement.requestDigest !== exactRequest.requestDigest ||
+        exactAcknowledgement.historyMessagesSent !== 0 ||
+        (exactAcknowledgement.status !== "accepted" &&
+            exactAcknowledgement.status !== "replayed")) {
+        return false;
+    }
+    const actual = exactAcknowledgement.actualBoundary;
+    if (actual !== undefined && !boundaryProofMatchesRun(exactRequest.run, actual)) {
+        return false;
+    }
+    return (actual !== undefined &&
+        Date.parse(actual.observedAt) >=
+            Date.parse(exactRequest.expectedBoundary.observedAt) &&
+        wireDigest(actual.boundary) ===
+            wireDigest(exactRequest.expectedBoundary.boundary));
+}
+function boundaryProofMatchesRun(run, proof) {
+    return (proof.runId === run.runId &&
+        proof.provider === run.provider &&
+        proof.environmentId === run.environmentId &&
+        proof.sessionId === run.sessionId &&
+        proof.executionId === run.executionId &&
+        proof.requestDigest === run.requestDigest);
+}