@tangle-network/agent-interface 0.45.0 → 0.46.0

package/dist/workspace-branching.js

@@ -1,400 +1,4 @@
-import { z } from "zod";
-import { canonicalCandidateDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
-import { AgentRunControlRefSchema, } from "./runtime-control.js";
-const idSchema = z.string().min(1).max(512);
-const jsonRecordSchema = z.record(z.string(), z.json());
-function wireDigest(value) {
-    const serialized = JSON.stringify(value);
-    if (serialized === undefined) {
-        throw new Error("operation material must be JSON serializable");
-    }
-    return canonicalCandidateDigest(JSON.parse(serialized));
-}
-export function workspaceCheckpointRequestDigest(material) {
-    return wireDigest(material);
-}
-export const WorkspaceCheckpointRequestSchema = z
-    .strictObject({
-    source: AgentRunControlRefSchema,
-    name: z.string().min(1).optional(),
-    metadata: jsonRecordSchema.optional(),
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-})
-    .superRefine((request, refinement) => {
-    if (request.requestDigest !==
-        workspaceCheckpointRequestDigest({
-            source: request.source,
-            name: request.name,
-            metadata: request.metadata,
-        })) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["requestDigest"],
-            message: "checkpoint request digest does not match its material",
-        });
-    }
-});
-export const WorkspaceCheckpointRefSchema = z
-    .strictObject({
-    checkpointId: idSchema,
-    provider: idSchema,
-    source: AgentRunControlRefSchema,
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-    createdAt: z.iso.datetime(),
-    metadata: jsonRecordSchema.optional(),
-})
-    .superRefine((checkpoint, refinement) => {
-    if (checkpoint.provider !== checkpoint.source.provider) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["provider"],
-            message: "checkpoint provider must match its source run",
-        });
-    }
-});
-const checkpointOperationBase = {
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-};
-export const WorkspaceCheckpointResultSchema = z.discriminatedUnion("status", [
-    z.strictObject({
-        status: z.enum(["created", "replayed"]),
-        ...checkpointOperationBase,
-        checkpoint: WorkspaceCheckpointRefSchema,
-    }),
-    z.strictObject({
-        status: z.literal("conflict"),
-        ...checkpointOperationBase,
-        existingRequestDigest: sha256DigestSchema,
-    }),
-    z.strictObject({
-        status: z.literal("unknown"),
-        ...checkpointOperationBase,
-        message: z.string().min(1),
-        retryable: z.boolean(),
-    }),
-]).superRefine((result, refinement) => {
-    if ((result.status === "created" || result.status === "replayed") &&
-        (result.checkpoint.idempotencyKey !== result.idempotencyKey ||
-            result.checkpoint.requestDigest !== result.requestDigest)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["checkpoint"],
-            message: "checkpoint identity must match its operation",
-        });
-    }
-    if (result.status === "conflict" &&
-        result.existingRequestDigest === result.requestDigest) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "a conflict must identify a different existing request",
-        });
-    }
-});
-export const WorkspaceOperationLookupRequestSchema = z.strictObject({
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-});
-export const WorkspaceCheckpointLookupResultSchema = z.discriminatedUnion("status", [
-    z.strictObject({
-        status: z.literal("found"),
-        ...checkpointOperationBase,
-        checkpoint: WorkspaceCheckpointRefSchema,
-    }),
-    z.strictObject({
-        status: z.literal("not_found"),
-        ...checkpointOperationBase,
-    }),
-    z.strictObject({
-        status: z.literal("conflict"),
-        ...checkpointOperationBase,
-        existingRequestDigest: sha256DigestSchema,
-    }),
-    z.strictObject({
-        status: z.literal("unknown"),
-        ...checkpointOperationBase,
-        message: z.string().min(1),
-        retryable: z.boolean(),
-    }),
-]).superRefine((result, refinement) => {
-    if (result.status === "found" &&
-        (result.checkpoint.idempotencyKey !== result.idempotencyKey ||
-            result.checkpoint.requestDigest !== result.requestDigest)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["checkpoint"],
-            message: "checkpoint identity must match its lookup operation",
-        });
-    }
-    if (result.status === "conflict" &&
-        result.existingRequestDigest === result.requestDigest) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "a conflict must identify a different existing request",
-        });
-    }
-});
-export function workspaceForkRequestDigest(material) {
-    return wireDigest(material);
-}
-export const WorkspaceForkRequestSchema = z
-    .strictObject({
-    checkpoint: WorkspaceCheckpointRefSchema,
-    name: z.string().min(1).optional(),
-    metadata: jsonRecordSchema.optional(),
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-})
-    .superRefine((request, refinement) => {
-    if (request.requestDigest !==
-        workspaceForkRequestDigest({
-            checkpoint: request.checkpoint,
-            name: request.name,
-            metadata: request.metadata,
-        })) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["requestDigest"],
-            message: "fork request digest does not match its material",
-        });
-    }
-});
-const PlacementInfoSchema = z.strictObject({
-    kind: z.enum(["local", "sandbox", "fleet", "provider"]),
-    sandboxId: idSchema.optional(),
-    fleetId: idSchema.optional(),
-    machineId: idSchema.optional(),
-    region: z.string().min(1).optional(),
-    providerMetadata: jsonRecordSchema.optional(),
-});
-export const ForkedEnvironmentRefSchema = z.strictObject({
-    provider: idSchema,
-    environmentId: idSchema,
-    sourceCheckpointId: idSchema,
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-    createdAt: z.iso.datetime(),
-    placement: PlacementInfoSchema.optional(),
-    confidential: z.boolean(),
-    metadata: jsonRecordSchema.optional(),
-});
-const forkOperationBase = {
-    idempotencyKey: idSchema,
-    requestDigest: sha256DigestSchema,
-};
-export const WorkspaceForkResultSchema = z.discriminatedUnion("status", [
-    z.strictObject({
-        status: z.enum(["created", "replayed"]),
-        ...forkOperationBase,
-        environment: ForkedEnvironmentRefSchema,
-    }),
-    z.strictObject({
-        status: z.literal("conflict"),
-        ...forkOperationBase,
-        existingRequestDigest: sha256DigestSchema,
-    }),
-    z.strictObject({
-        status: z.literal("unknown"),
-        ...forkOperationBase,
-        message: z.string().min(1),
-        retryable: z.boolean(),
-    }),
-]).superRefine((result, refinement) => {
-    if ((result.status === "created" || result.status === "replayed") &&
-        (result.environment.idempotencyKey !== result.idempotencyKey ||
-            result.environment.requestDigest !== result.requestDigest)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["environment"],
-            message: "forked environment identity must match its operation",
-        });
-    }
-    if (result.status === "conflict" &&
-        result.existingRequestDigest === result.requestDigest) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "a conflict must identify a different existing request",
-        });
-    }
-});
-export const WorkspaceForkLookupResultSchema = z.discriminatedUnion("status", [
-    z.strictObject({
-        status: z.literal("found"),
-        ...forkOperationBase,
-        environment: ForkedEnvironmentRefSchema,
-    }),
-    z.strictObject({ status: z.literal("not_found"), ...forkOperationBase }),
-    z.strictObject({
-        status: z.literal("conflict"),
-        ...forkOperationBase,
-        existingRequestDigest: sha256DigestSchema,
-    }),
-    z.strictObject({
-        status: z.literal("unknown"),
-        ...forkOperationBase,
-        message: z.string().min(1),
-        retryable: z.boolean(),
-    }),
-]).superRefine((result, refinement) => {
-    if (result.status === "found" &&
-        (result.environment.idempotencyKey !== result.idempotencyKey ||
-            result.environment.requestDigest !== result.requestDigest)) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["environment"],
-            message: "forked environment identity must match its lookup operation",
-        });
-    }
-    if (result.status === "conflict" &&
-        result.existingRequestDigest === result.requestDigest) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["existingRequestDigest"],
-            message: "a conflict must identify a different existing request",
-        });
-    }
-});
-export const WorkspaceCleanupRequestSchema = z.strictObject({
-    operationId: idSchema,
-    targetId: idSchema,
-    provider: idSchema,
-});
-export const WorkspaceCleanupAcknowledgementSchema = z
-    .strictObject({
-    operationId: idSchema,
-    targetId: idSchema,
-    provider: idSchema,
-    status: z.enum([
-        "deleted",
-        "already_absent",
-        "unknown",
-        "in_use",
-        "conflict",
-        "transport_failure",
-    ]),
-    message: z.string().min(1).optional(),
-    retryable: z.boolean().optional(),
-    /** Existing resources that must be removed before this target. */
-    blockingTargetIds: z.array(idSchema).min(1).optional(),
-})
-    .superRefine((acknowledgement, refinement) => {
-    if (["unknown", "in_use", "conflict", "transport_failure"].includes(acknowledgement.status) &&
-        acknowledgement.message === undefined) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["message"],
-            message: `${acknowledgement.status} cleanup must include a message`,
-        });
-    }
-    if (acknowledgement.status === "in_use" &&
-        acknowledgement.blockingTargetIds === undefined) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["blockingTargetIds"],
-            message: "in_use cleanup must identify every known blocking target",
-        });
-    }
-    if (acknowledgement.status !== "in_use" &&
-        acknowledgement.blockingTargetIds !== undefined) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["blockingTargetIds"],
-            message: "only in_use cleanup may identify blocking targets",
-        });
-    }
-    if (acknowledgement.blockingTargetIds &&
-        new Set(acknowledgement.blockingTargetIds).size !==
-            acknowledgement.blockingTargetIds.length) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["blockingTargetIds"],
-            message: "blocking cleanup target ids must be unique",
-        });
-    }
-    if (["unknown", "transport_failure"].includes(acknowledgement.status) &&
-        acknowledgement.retryable === undefined) {
-        refinement.addIssue({
-            code: "custom",
-            path: ["retryable"],
-            message: `${acknowledgement.status} cleanup must state whether retry is safe`,
-        });
-    }
-});
-/** Bind a checkpoint result to the exact request before using the resource. */
-export function workspaceCheckpointResultMatchesRequest(request, result) {
-    const parsedRequest = WorkspaceCheckpointRequestSchema.safeParse(request);
-    const parsedResult = WorkspaceCheckpointResultSchema.safeParse(result);
-    const parsedLookup = WorkspaceCheckpointLookupResultSchema.safeParse(result);
-    if (!parsedRequest.success)
-        return false;
-    const exactRequest = parsedRequest.data;
-    if (parsedResult.success &&
-        (parsedResult.data.status === "created" ||
-            parsedResult.data.status === "replayed")) {
-        return checkpointResultMatchesParsed(exactRequest, parsedResult.data);
-    }
-    if (parsedLookup.success && parsedLookup.data.status === "found") {
-        return checkpointResultMatchesParsed(exactRequest, parsedLookup.data);
-    }
-    return false;
-}
-function checkpointResultMatchesParsed(request, result) {
-    return (result.idempotencyKey === request.idempotencyKey &&
-        result.requestDigest === request.requestDigest &&
-        result.checkpoint.idempotencyKey === request.idempotencyKey &&
-        result.checkpoint.requestDigest === request.requestDigest &&
-        wireDigest(result.checkpoint.source) === wireDigest(request.source) &&
-        sameOptionalWireValue(result.checkpoint.metadata, request.metadata) &&
-        result.checkpoint.provider === request.source.provider);
-}
-/** Bind a fork result to the exact checkpoint request before using it. */
-export function workspaceForkResultMatchesRequest(request, result) {
-    const parsedRequest = WorkspaceForkRequestSchema.safeParse(request);
-    const parsedResult = WorkspaceForkResultSchema.safeParse(result);
-    const parsedLookup = WorkspaceForkLookupResultSchema.safeParse(result);
-    if (!parsedRequest.success)
-        return false;
-    const exactRequest = parsedRequest.data;
-    if (parsedResult.success &&
-        (parsedResult.data.status === "created" ||
-            parsedResult.data.status === "replayed")) {
-        return forkResultMatchesParsed(exactRequest, parsedResult.data);
-    }
-    if (parsedLookup.success && parsedLookup.data.status === "found") {
-        return forkResultMatchesParsed(exactRequest, parsedLookup.data);
-    }
-    return false;
-}
-function forkResultMatchesParsed(request, result) {
-    return (result.idempotencyKey === request.idempotencyKey &&
-        result.requestDigest === request.requestDigest &&
-        result.environment.idempotencyKey === request.idempotencyKey &&
-        result.environment.requestDigest === request.requestDigest &&
-        result.environment.sourceCheckpointId === request.checkpoint.checkpointId &&
-        result.environment.provider === request.checkpoint.provider &&
-        sameOptionalWireValue(result.environment.metadata, request.metadata));
-}
-/** Bind cleanup confirmation to the exact provider resource and operation. */
-export function workspaceCleanupAcknowledgementMatches(request, acknowledgement) {
-    const parsedRequest = WorkspaceCleanupRequestSchema.safeParse(request);
-    const parsedAcknowledgement = WorkspaceCleanupAcknowledgementSchema.safeParse(acknowledgement);
-    if (!parsedRequest.success || !parsedAcknowledgement.success)
-        return false;
-    const exactRequest = parsedRequest.data;
-    const exactAcknowledgement = parsedAcknowledgement.data;
-    return ((exactAcknowledgement.status === "deleted" ||
-        exactAcknowledgement.status === "already_absent") &&
-        exactAcknowledgement.operationId === exactRequest.operationId &&
-        exactAcknowledgement.targetId === exactRequest.targetId &&
-        exactAcknowledgement.provider === exactRequest.provider);
-}
-function sameOptionalWireValue(left, right) {
-    if (left === undefined || right === undefined)
-        return left === right;
-    return wireDigest(left) === wireDigest(right);
-}
+export * from "./workspace-confidentiality.js";
+export * from "./workspace-checkpoint.js";
+export * from "./workspace-fork.js";
+export * from "./workspace-cleanup.js";

package/dist/workspace-checkpoint.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type AgentExactRunControlRef } from "./runtime-control.js";
+export interface WorkspaceCheckpointMaterial {
+    source: AgentExactRunControlRef;
+    name?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface WorkspaceCheckpointRequest extends WorkspaceCheckpointMaterial {
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+}
+export declare function workspaceCheckpointRequestDigest(material: WorkspaceCheckpointMaterial): Sha256Digest;
+export declare const WorkspaceCheckpointRequestSchema: z.ZodObject<{
+    source: 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>;
+    name: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export interface WorkspaceCheckpointRef {
+    checkpointId: string;
+    provider: string;
+    source: AgentExactRunControlRef;
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}
+export declare const WorkspaceCheckpointRefSchema: z.ZodObject<{
+    checkpointId: z.ZodString;
+    provider: z.ZodString;
+    source: 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>;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    createdAt: z.ZodISODateTime;
+    metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
+export type WorkspaceCheckpointResult = {
+    status: "created" | "replayed";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    checkpoint: WorkspaceCheckpointRef;
+} | {
+    status: "conflict";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    existingRequestDigest: Sha256Digest;
+} | {
+    status: "unknown";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    message: string;
+    retryable: boolean;
+};
+export declare const WorkspaceCheckpointResultSchema: z.ZodType<WorkspaceCheckpointResult>;
+export declare const WorkspaceOperationLookupRequestSchema: z.ZodObject<{
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export type WorkspaceOperationLookupRequest = z.infer<typeof WorkspaceOperationLookupRequestSchema>;
+export type WorkspaceCheckpointLookupResult = {
+    status: "found";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    checkpoint: WorkspaceCheckpointRef;
+} | {
+    status: "not_found";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+} | {
+    status: "conflict";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    existingRequestDigest: Sha256Digest;
+} | {
+    status: "unknown";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    message: string;
+    retryable: boolean;
+};
+export declare const WorkspaceCheckpointLookupResultSchema: z.ZodType<WorkspaceCheckpointLookupResult>;
+/** Bind a checkpoint result to the exact request before using the resource. */
+export declare function workspaceCheckpointResultMatchesRequest(request: WorkspaceCheckpointRequest, result: WorkspaceCheckpointResult | WorkspaceCheckpointLookupResult): boolean;

package/dist/workspace-checkpoint.js

@@ -0,0 +1,169 @@
+import { z } from "zod";
+import { AgentExactRunControlRefSchema } from "./runtime-control.js";
+import { idSchema, jsonRecordSchema, sameOptionalWireValue, sha256DigestSchema, wireDigest } from "./workspace-branching-shared.js";
+import { boundedStringSchema } from "./contract-limits.js";
+const WorkspaceCheckpointMaterialSchema = z.strictObject({
+    source: AgentExactRunControlRefSchema,
+    name: idSchema.optional(),
+    metadata: jsonRecordSchema.optional(),
+});
+export function workspaceCheckpointRequestDigest(material) {
+    const parsed = WorkspaceCheckpointMaterialSchema.parse(material);
+    return wireDigest({
+        source: parsed.source,
+        ...(parsed.name === undefined ? {} : { name: parsed.name }),
+        ...(parsed.metadata === undefined ? {} : { metadata: parsed.metadata }),
+    });
+}
+export const WorkspaceCheckpointRequestSchema = z
+    .strictObject({
+    source: AgentExactRunControlRefSchema,
+    name: idSchema.optional(),
+    metadata: jsonRecordSchema.optional(),
+    idempotencyKey: idSchema,
+    requestDigest: sha256DigestSchema,
+})
+    .superRefine((request, refinement) => {
+    if (request.requestDigest !==
+        workspaceCheckpointRequestDigest({
+            source: request.source,
+            name: request.name,
+            metadata: request.metadata,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "checkpoint request digest does not match its material",
+        });
+    }
+});
+export const WorkspaceCheckpointRefSchema = z
+    .strictObject({
+    checkpointId: idSchema,
+    provider: idSchema,
+    source: AgentExactRunControlRefSchema,
+    idempotencyKey: idSchema,
+    requestDigest: sha256DigestSchema,
+    createdAt: z.iso.datetime().max(64),
+    metadata: jsonRecordSchema.optional(),
+})
+    .superRefine((checkpoint, refinement) => {
+    if (checkpoint.provider !== checkpoint.source.provider) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["provider"],
+            message: "checkpoint provider must match its source run",
+        });
+    }
+});
+const checkpointOperationBase = {
+    idempotencyKey: idSchema,
+    requestDigest: sha256DigestSchema,
+};
+export const WorkspaceCheckpointResultSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        status: z.enum(["created", "replayed"]),
+        ...checkpointOperationBase,
+        checkpoint: WorkspaceCheckpointRefSchema,
+    }),
+    z.strictObject({
+        status: z.literal("conflict"),
+        ...checkpointOperationBase,
+        existingRequestDigest: sha256DigestSchema,
+    }),
+    z.strictObject({
+        status: z.literal("unknown"),
+        ...checkpointOperationBase,
+        message: boundedStringSchema.min(1),
+        retryable: z.boolean(),
+    }),
+]).superRefine((result, refinement) => {
+    if ((result.status === "created" || result.status === "replayed") &&
+        (result.checkpoint.idempotencyKey !== result.idempotencyKey ||
+            result.checkpoint.requestDigest !== result.requestDigest)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["checkpoint"],
+            message: "checkpoint identity must match its operation",
+        });
+    }
+    if (result.status === "conflict" &&
+        result.existingRequestDigest === result.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a conflict must identify a different existing request",
+        });
+    }
+});
+export const WorkspaceOperationLookupRequestSchema = z.strictObject({
+    idempotencyKey: idSchema,
+    requestDigest: sha256DigestSchema,
+});
+export const WorkspaceCheckpointLookupResultSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        status: z.literal("found"),
+        ...checkpointOperationBase,
+        checkpoint: WorkspaceCheckpointRefSchema,
+    }),
+    z.strictObject({
+        status: z.literal("not_found"),
+        ...checkpointOperationBase,
+    }),
+    z.strictObject({
+        status: z.literal("conflict"),
+        ...checkpointOperationBase,
+        existingRequestDigest: sha256DigestSchema,
+    }),
+    z.strictObject({
+        status: z.literal("unknown"),
+        ...checkpointOperationBase,
+        message: boundedStringSchema.min(1),
+        retryable: z.boolean(),
+    }),
+]).superRefine((result, refinement) => {
+    if (result.status === "found" &&
+        (result.checkpoint.idempotencyKey !== result.idempotencyKey ||
+            result.checkpoint.requestDigest !== result.requestDigest)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["checkpoint"],
+            message: "checkpoint identity must match its lookup operation",
+        });
+    }
+    if (result.status === "conflict" &&
+        result.existingRequestDigest === result.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a conflict must identify a different existing request",
+        });
+    }
+});
+/** Bind a checkpoint result to the exact request before using the resource. */
+export function workspaceCheckpointResultMatchesRequest(request, result) {
+    const parsedRequest = WorkspaceCheckpointRequestSchema.safeParse(request);
+    const parsedResult = WorkspaceCheckpointResultSchema.safeParse(result);
+    const parsedLookup = WorkspaceCheckpointLookupResultSchema.safeParse(result);
+    if (!parsedRequest.success)
+        return false;
+    const exactRequest = parsedRequest.data;
+    if (parsedResult.success &&
+        (parsedResult.data.status === "created" ||
+            parsedResult.data.status === "replayed")) {
+        return checkpointResultMatchesParsed(exactRequest, parsedResult.data);
+    }
+    if (parsedLookup.success && parsedLookup.data.status === "found") {
+        return checkpointResultMatchesParsed(exactRequest, parsedLookup.data);
+    }
+    return false;
+}
+function checkpointResultMatchesParsed(request, result) {
+    return (result.idempotencyKey === request.idempotencyKey &&
+        result.requestDigest === request.requestDigest &&
+        result.checkpoint.idempotencyKey === request.idempotencyKey &&
+        result.checkpoint.requestDigest === request.requestDigest &&
+        wireDigest(result.checkpoint.source) === wireDigest(request.source) &&
+        sameOptionalWireValue(result.checkpoint.metadata, request.metadata) &&
+        result.checkpoint.provider === request.source.provider);
+}