@tangle-network/agent-interface 0.45.0 → 0.46.0

package/dist/workspace-cleanup.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import type { WorkspaceCheckpointRequest } from "./workspace-checkpoint.js";
+import type { WorkspaceCheckpointLookupResult, WorkspaceCheckpointResult, WorkspaceOperationLookupRequest } from "./workspace-checkpoint.js";
+import type { WorkspaceForkRequest } from "./workspace-fork.js";
+import type { WorkspaceForkLookupResult, WorkspaceForkResult } from "./workspace-fork.js";
+/**
+ * Checkpoints and forked environments are separate resources with separate
+ * destroy authority, so every cleanup names which kind it addresses and the
+ * acknowledgement must echo it. Without this, one identifier shape reaches
+ * both operations and a swapped target destroys the wrong resource.
+ */
+export declare const WorkspaceCleanupKindSchema: z.ZodEnum<{
+    checkpoint: "checkpoint";
+    fork: "fork";
+}>;
+export type WorkspaceCleanupKind = z.infer<typeof WorkspaceCleanupKindSchema>;
+export interface WorkspaceCleanupMaterial {
+    kind: WorkspaceCleanupKind;
+    targetId: string;
+    provider: string;
+}
+/** Digest the exact resource addressed by a cleanup operation. */
+export declare function workspaceCleanupRequestDigest(material: WorkspaceCleanupMaterial): Sha256Digest;
+export declare const WorkspaceCleanupRequestSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    kind: z.ZodEnum<{
+        checkpoint: "checkpoint";
+        fork: "fork";
+    }>;
+    targetId: z.ZodString;
+    provider: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export type WorkspaceCleanupRequest = z.infer<typeof WorkspaceCleanupRequestSchema>;
+export declare const WorkspaceCleanupAcknowledgementSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    kind: z.ZodEnum<{
+        checkpoint: "checkpoint";
+        fork: "fork";
+    }>;
+    targetId: z.ZodString;
+    provider: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        conflict: "conflict";
+        transport_failure: "transport_failure";
+        deleted: "deleted";
+        already_absent: "already_absent";
+        in_use: "in_use";
+    }>;
+    existingRequestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+    message: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    blockingTargetIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type WorkspaceCleanupAcknowledgement = z.infer<typeof WorkspaceCleanupAcknowledgementSchema>;
+/** Optional durable workspace branch operations implemented by capable providers. */
+export interface AgentWorkspaceBranching {
+    checkpoint(request: WorkspaceCheckpointRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceCheckpointResult>;
+    lookupCheckpoint(request: WorkspaceOperationLookupRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceCheckpointLookupResult>;
+    deleteCheckpoint(request: WorkspaceCleanupRequest & {
+        kind: "checkpoint";
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceCleanupAcknowledgement>;
+    fork(request: WorkspaceForkRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceForkResult>;
+    lookupFork(request: WorkspaceOperationLookupRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceForkLookupResult>;
+    destroyFork(request: WorkspaceCleanupRequest & {
+        kind: "fork";
+    }, options?: {
+        signal?: AbortSignal;
+    }): Promise<WorkspaceCleanupAcknowledgement>;
+}
+/** Bind cleanup confirmation to the exact provider resource and operation. */
+export declare function workspaceCleanupAcknowledgementMatches(request: WorkspaceCleanupRequest, acknowledgement: WorkspaceCleanupAcknowledgement): boolean;

package/dist/workspace-cleanup.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { canonicalCandidateDigest } from "./agent-candidate-schema-common.js";
+import { idSchema, sha256DigestSchema } from "./workspace-branching-shared.js";
+import { boundedStringSchema, CONTRACT_MAX_ARRAY_LENGTH } from "./contract-limits.js";
+/**
+ * Checkpoints and forked environments are separate resources with separate
+ * destroy authority, so every cleanup names which kind it addresses and the
+ * acknowledgement must echo it. Without this, one identifier shape reaches
+ * both operations and a swapped target destroys the wrong resource.
+ */
+export const WorkspaceCleanupKindSchema = z.enum(["checkpoint", "fork"]);
+const WorkspaceCleanupMaterialSchema = z.strictObject({
+    kind: WorkspaceCleanupKindSchema,
+    targetId: idSchema,
+    provider: idSchema,
+});
+/** Digest the exact resource addressed by a cleanup operation. */
+export function workspaceCleanupRequestDigest(material) {
+    return canonicalCandidateDigest(WorkspaceCleanupMaterialSchema.parse(material));
+}
+export const WorkspaceCleanupRequestSchema = z.strictObject({
+    operationId: idSchema,
+    kind: WorkspaceCleanupKindSchema,
+    targetId: idSchema,
+    provider: idSchema,
+    requestDigest: sha256DigestSchema,
+}).superRefine((request, refinement) => {
+    if (request.requestDigest !==
+        workspaceCleanupRequestDigest({
+            kind: request.kind,
+            targetId: request.targetId,
+            provider: request.provider,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "cleanup request digest does not match its target",
+        });
+    }
+});
+export const WorkspaceCleanupAcknowledgementSchema = z
+    .strictObject({
+    operationId: idSchema,
+    kind: WorkspaceCleanupKindSchema,
+    targetId: idSchema,
+    provider: idSchema,
+    requestDigest: sha256DigestSchema,
+    status: z.enum([
+        "deleted",
+        "already_absent",
+        "unknown",
+        "in_use",
+        "conflict",
+        "transport_failure",
+    ]),
+    existingRequestDigest: sha256DigestSchema.optional(),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+    /** Existing resources that must be removed before this target. */
+    blockingTargetIds: z.array(idSchema).min(1).max(CONTRACT_MAX_ARRAY_LENGTH).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`,
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a cleanup conflict must include the existing digest",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === acknowledgement.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a cleanup conflict must identify a different request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only a cleanup conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.requestDigest !==
+        workspaceCleanupRequestDigest({
+            kind: acknowledgement.kind,
+            targetId: acknowledgement.targetId,
+            provider: acknowledgement.provider,
+        })) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "cleanup acknowledgement digest does not match its target",
+        });
+    }
+});
+/** 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.kind === exactRequest.kind &&
+        exactAcknowledgement.targetId === exactRequest.targetId &&
+        exactAcknowledgement.provider === exactRequest.provider &&
+        exactAcknowledgement.requestDigest === exactRequest.requestDigest);
+}

package/dist/workspace-confidentiality.d.ts

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type AgentExactRunControlRef } from "./runtime-control.js";
+/**
+ * Evidence for a confidential environment. The signature is retained for an
+ * external provider-key check; this package never treats a self-echoed quote
+ * as authenticated on its own.
+ */
+export declare const ConfidentialAttestationSchema: z.ZodObject<{
+    provider: z.ZodString;
+    requested: z.ZodLiteral<true>;
+    nonce: z.ZodString;
+    measurement: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    environmentId: 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>;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    profileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    policy: z.ZodString;
+    quote: z.ZodString;
+    providerKeyId: z.ZodString;
+    providerSignature: z.ZodString;
+    verifiedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ConfidentialAttestation = z.infer<typeof ConfidentialAttestationSchema>;
+/** What the caller asked for, separate from what the provider proved. */
+export declare const ConfidentialExecutionRequestSchema: z.ZodObject<{
+    requested: z.ZodBoolean;
+    nonce: z.ZodOptional<z.ZodString>;
+    policy: z.ZodOptional<z.ZodString>;
+    profileDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+}, z.core.$strict>;
+export type ConfidentialExecutionRequest = z.infer<typeof ConfidentialExecutionRequestSchema>;
+export interface ConfidentialExecutionEnvironment {
+    provider: string;
+    environmentId: string;
+    source: AgentExactRunControlRef;
+    requestDigest: Sha256Digest;
+    confidentialRequested: boolean;
+}
+export type ConfidentialAttestationVerifier = (attestation: ConfidentialAttestation, expected: ConfidentialExecutionEnvironment) => boolean;
+/**
+ * Verify every request/result binding and require an external provider-key
+ * check before exposing a positive confidentiality result.
+ */
+export declare function confidentialExecutionVerified(input: {
+    request: ConfidentialExecutionRequest;
+    environment: ConfidentialExecutionEnvironment;
+    attestation?: ConfidentialAttestation;
+    verifyProviderAttestation?: ConfidentialAttestationVerifier;
+}): boolean;
+/** Digest over the complete confidentiality request. */
+export declare function confidentialExecutionRequestDigest(request: ConfidentialExecutionRequest): Sha256Digest;

package/dist/workspace-confidentiality.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { boundedStringSchema } from "./contract-limits.js";
+import { AgentExactRunControlRefSchema, } from "./runtime-control.js";
+import { idSchema, sha256DigestSchema, wireDigest } from "./workspace-branching-shared.js";
+/**
+ * Evidence for a confidential environment. The signature is retained for an
+ * external provider-key check; this package never treats a self-echoed quote
+ * as authenticated on its own.
+ */
+export const ConfidentialAttestationSchema = z
+    .strictObject({
+    provider: idSchema,
+    requested: z.literal(true),
+    nonce: idSchema,
+    measurement: sha256DigestSchema,
+    environmentId: idSchema,
+    source: AgentExactRunControlRefSchema,
+    requestDigest: sha256DigestSchema,
+    profileDigest: sha256DigestSchema,
+    policy: idSchema,
+    quote: boundedStringSchema.min(1),
+    providerKeyId: idSchema,
+    providerSignature: boundedStringSchema.min(1),
+    verifiedAt: z.iso.datetime().max(64),
+})
+    .superRefine((attestation, refinement) => {
+    if (attestation.nonce === attestation.policy) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["nonce"],
+            message: "attestation nonce must not reuse the policy identifier",
+        });
+    }
+    if (attestation.providerSignature === attestation.quote) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["providerSignature"],
+            message: "provider authentication must not be a copied quote",
+        });
+    }
+});
+/** What the caller asked for, separate from what the provider proved. */
+export const ConfidentialExecutionRequestSchema = z
+    .strictObject({
+    requested: z.boolean(),
+    nonce: idSchema.optional(),
+    policy: idSchema.optional(),
+    profileDigest: sha256DigestSchema.optional(),
+})
+    .superRefine((request, refinement) => {
+    const complete = request.nonce !== undefined &&
+        request.policy !== undefined &&
+        request.profileDigest !== undefined;
+    if (request.requested && !complete) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requested"],
+            message: "a confidential execution request must bind nonce, policy, and profile digest",
+        });
+    }
+    if (!request.requested && complete) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requested"],
+            message: "a non-confidential execution request cannot carry confidential admission fields",
+        });
+    }
+});
+/**
+ * Verify every request/result binding and require an external provider-key
+ * check before exposing a positive confidentiality result.
+ */
+export function confidentialExecutionVerified(input) {
+    const parsedRequest = ConfidentialExecutionRequestSchema.safeParse(input.request);
+    if (!parsedRequest.success || !parsedRequest.data.requested)
+        return false;
+    if (input.attestation === undefined || input.verifyProviderAttestation === undefined) {
+        return false;
+    }
+    const parsedEnvironment = z
+        .strictObject({
+        provider: idSchema,
+        environmentId: idSchema,
+        source: AgentExactRunControlRefSchema,
+        requestDigest: sha256DigestSchema,
+        confidentialRequested: z.literal(true),
+    })
+        .safeParse(input.environment);
+    const parsedAttestation = ConfidentialAttestationSchema.safeParse(input.attestation);
+    if (!parsedEnvironment.success || !parsedAttestation.success)
+        return false;
+    const request = parsedRequest.data;
+    const environment = parsedEnvironment.data;
+    const attestation = parsedAttestation.data;
+    if (request.nonce === undefined ||
+        request.policy === undefined ||
+        request.profileDigest === undefined ||
+        attestation.requested !== request.requested ||
+        attestation.provider !== environment.provider ||
+        attestation.environmentId !== environment.environmentId ||
+        attestation.source.provider !== environment.source.provider ||
+        wireDigest(attestation.source) !== wireDigest(environment.source) ||
+        attestation.requestDigest !== environment.requestDigest ||
+        attestation.nonce !== request.nonce ||
+        attestation.policy !== request.policy ||
+        attestation.profileDigest !== request.profileDigest ||
+        environment.confidentialRequested !== request.requested) {
+        return false;
+    }
+    return input.verifyProviderAttestation(attestation, environment) === true;
+}
+/** Digest over the complete confidentiality request. */
+export function confidentialExecutionRequestDigest(request) {
+    const parsed = ConfidentialExecutionRequestSchema.parse(request);
+    return wireDigest({
+        requested: parsed.requested,
+        ...(parsed.nonce === undefined ? {} : { nonce: parsed.nonce }),
+        ...(parsed.policy === undefined ? {} : { policy: parsed.policy }),
+        ...(parsed.profileDigest === undefined
+            ? {}
+            : { profileDigest: parsed.profileDigest }),
+    });
+}

package/dist/workspace-fork.d.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import type { PlacementInfo } from "./environment-requests.js";
+import { type AgentExactRunControlRef } from "./runtime-control.js";
+import { type WorkspaceCheckpointRef } from "./workspace-checkpoint.js";
+import { type ConfidentialAttestationVerifier, type ConfidentialAttestation, type ConfidentialExecutionRequest } from "./workspace-confidentiality.js";
+export interface WorkspaceForkMaterial {
+    checkpoint: WorkspaceCheckpointRef;
+    name?: string;
+    metadata?: Record<string, unknown>;
+    /** Requested placement is part of the operation identity. */
+    placement: PlacementInfo;
+    /** What the caller asked for; never what the provider proved. */
+    confidential?: ConfidentialExecutionRequest;
+}
+export interface WorkspaceForkRequest extends WorkspaceForkMaterial {
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+}
+export declare function workspaceForkRequestDigest(material: WorkspaceForkMaterial): Sha256Digest;
+export declare const WorkspaceForkRequestSchema: z.ZodObject<{
+    checkpoint: 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>;
+    name: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    placement: z.ZodObject<{
+        kind: z.ZodEnum<{
+            provider: "provider";
+            local: "local";
+            sandbox: "sandbox";
+            fleet: "fleet";
+        }>;
+        sandboxId: z.ZodOptional<z.ZodString>;
+        fleetId: z.ZodOptional<z.ZodString>;
+        machineId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    }, z.core.$strict>;
+    confidential: z.ZodOptional<z.ZodObject<{
+        requested: z.ZodBoolean;
+        nonce: z.ZodOptional<z.ZodString>;
+        policy: z.ZodOptional<z.ZodString>;
+        profileDigest: z.ZodOptional<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>>;
+}, z.core.$strict>;
+export interface ForkedEnvironmentRef {
+    provider: string;
+    environmentId: string;
+    /** Environment the checkpoint was taken from; a fork must never reuse it. */
+    sourceEnvironmentId: string;
+    /** Full source run identity; an environment id alone is not sufficient. */
+    source: AgentExactRunControlRef;
+    sourceCheckpointId: string;
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    createdAt: string;
+    placement: PlacementInfo;
+    /**
+     * What the caller asked for. This is never proof: read it with
+     * {@link forkedEnvironmentConfidentialityVerified}, never on its own.
+     */
+    confidentialRequested: boolean;
+    /** Present only when the provider produced verifiable attestation evidence. */
+    confidentialAttestation?: ConfidentialAttestation;
+    /** Legacy assertion retained for wire compatibility; never trusted as proof. */
+    confidential?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export declare const ForkedEnvironmentRefSchema: z.ZodObject<{
+    provider: z.ZodString;
+    environmentId: z.ZodString;
+    sourceEnvironmentId: 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>;
+    sourceCheckpointId: z.ZodString;
+    idempotencyKey: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    createdAt: z.ZodISODateTime;
+    placement: z.ZodObject<{
+        kind: z.ZodEnum<{
+            provider: "provider";
+            local: "local";
+            sandbox: "sandbox";
+            fleet: "fleet";
+        }>;
+        sandboxId: z.ZodOptional<z.ZodString>;
+        fleetId: z.ZodOptional<z.ZodString>;
+        machineId: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        providerMetadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    }, z.core.$strict>;
+    confidentialRequested: z.ZodBoolean;
+    confidentialAttestation: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        requested: z.ZodLiteral<true>;
+        nonce: z.ZodString;
+        measurement: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        environmentId: 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>;
+        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        profileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        policy: z.ZodString;
+        quote: z.ZodString;
+        providerKeyId: z.ZodString;
+        providerSignature: z.ZodString;
+        verifiedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    confidential: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
+/** The only supported way to decide whether a fork may be shown confidential. */
+export declare function forkedEnvironmentConfidentialityVerified(request: WorkspaceForkRequest, environment: ForkedEnvironmentRef, verifyProviderAttestation?: ConfidentialAttestationVerifier): boolean;
+export type WorkspaceForkResult = {
+    status: "created" | "replayed";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    environment: ForkedEnvironmentRef;
+} | {
+    status: "conflict";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    existingRequestDigest: Sha256Digest;
+} | {
+    status: "unknown";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    message: string;
+    retryable: boolean;
+};
+export declare const WorkspaceForkResultSchema: z.ZodType<WorkspaceForkResult>;
+export type WorkspaceForkLookupResult = {
+    status: "found";
+    idempotencyKey: string;
+    requestDigest: Sha256Digest;
+    environment: ForkedEnvironmentRef;
+} | {
+    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 WorkspaceForkLookupResultSchema: z.ZodType<WorkspaceForkLookupResult>;
+export declare function workspaceForkResultMatchesRequest(request: WorkspaceForkRequest, result: WorkspaceForkResult | WorkspaceForkLookupResult): boolean;