@tangle-network/agent-interface 0.45.0 → 0.46.0

package/dist/environment-runtime.d.ts

@@ -0,0 +1,834 @@
+import { z } from "zod";
+import type { AgentProfileCapabilities, AgentProfileValidationResult } from "./agent-profile.js";
+import type { InputPart } from "./parts.js";
+import type { StreamEvent } from "./stream-events.js";
+import type { TokenUsage } from "./execution-types.js";
+import { type InteractionAcknowledgement, type InteractionCapabilities, type InteractionResponseCommand } from "./interaction.js";
+import { type ContextTransferReceipt, type ContextTransferRequest, type NativeContextBoundaryProof, type NativeContextContinuationRequest, type NativeContextContinuationTurn } from "./portable-context.js";
+import { type AgentRunCancellationAcknowledgement, type AgentRunCancellationRequest, type AgentRunControlRef } from "./runtime-control.js";
+import type { AgentWorkspaceBranching } from "./workspace-branching.js";
+import type { AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSessionStatus, CheckpointRef, CheckpointRequest, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "./environment-requests.js";
+import type { AgentExactProcessEgressMode, AgentExactProcessProvider } from "./environment-exact-process.js";
+export interface AgentTurnInput {
+    prompt?: string;
+    parts?: InputPart[];
+    sessionId?: string;
+    model?: string;
+    timeoutMs?: number;
+    executionId?: string;
+    lastEventId?: string;
+    turnId?: string;
+    detach?: boolean;
+    /** Stable coordinates for a retained run when one already exists. */
+    controlRef?: AgentRunControlRef;
+    /** Approved portable history for a fresh provider session. */
+    contextTransfer?: ContextTransferRequest;
+    /** Verified same-session continuation; never carries duplicate history. */
+    nativeContinuation?: NativeContextContinuationRequest;
+    context?: Record<string, unknown>;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, unknown>;
+}
+export declare const AgentTurnInputSchema: 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">>>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    executionId: z.ZodOptional<z.ZodString>;
+    lastEventId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    detach: z.ZodOptional<z.ZodBoolean>;
+    controlRef: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        provider: z.ZodString;
+        environmentId: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        executionId: z.ZodOptional<z.ZodString>;
+        requestDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+    }, z.core.$strict>>;
+    contextTransfer: z.ZodOptional<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>>;
+    nativeContinuation: z.ZodOptional<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>>;
+    context: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+    providerOptions: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+}, z.core.$strict>;
+export interface AgentTurnResult {
+    text: string;
+    success: boolean;
+    error?: string;
+    sessionId?: string;
+    usage?: TokenUsage;
+    metadata?: Record<string, unknown>;
+    events?: AgentEnvironmentEvent[];
+    contextTransferReceipt?: ContextTransferReceipt;
+}
+/** Runtime validator for a provider turn returned from durable continuation. */
+export declare const AgentTurnResultSchema: z.ZodObject<{
+    text: z.ZodString;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+        reasoningTokens: z.ZodOptional<z.ZodNumber>;
+        cost: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        data: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+        id: z.ZodOptional<z.ZodString>;
+        normalized: z.ZodOptional<z.ZodType<StreamEvent, unknown, z.core.$ZodTypeInternals<StreamEvent, unknown>>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+            cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+            reasoningTokens: z.ZodOptional<z.ZodNumber>;
+            cost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        providerEvent: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
+    }, z.core.$strict>>>;
+    contextTransferReceipt: z.ZodOptional<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">>;
+}, z.core.$strict>;
+/** Durable provider result for one digest-bound native continuation. */
+export declare const AgentNativeContextContinuationResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    acknowledgement: z.ZodIntersection<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>, z.ZodObject<{
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            replayed: "replayed";
+        }>;
+    }, z.core.$strip>>;
+    result: z.ZodObject<{
+        text: z.ZodString;
+        success: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+            cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+            reasoningTokens: z.ZodOptional<z.ZodNumber>;
+            cost: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        metadata: z.ZodOptional<z.ZodCustom<Record<string, unknown>, Record<string, unknown>>>;
+        events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            data: z.ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+            id: z.ZodOptional<z.ZodString>;
+            normalized: z.ZodOptional<z.ZodType<StreamEvent, unknown, z.core.$ZodTypeInternals<StreamEvent, unknown>>>;
+            usage: z.ZodOptional<z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                totalTokens: z.ZodOptional<z.ZodNumber>;
+                cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+                cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+                reasoningTokens: z.ZodOptional<z.ZodNumber>;
+                cost: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            providerEvent: z.ZodOptional<z.ZodCustom<unknown, unknown>>;
+        }, z.core.$strict>>>;
+        contextTransferReceipt: z.ZodOptional<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">>;
+    }, z.core.$strict>;
+    controlRef: 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>;
+}, z.core.$strict>, z.ZodObject<{
+    acknowledgement: z.ZodIntersection<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>, z.ZodObject<{
+        status: z.ZodEnum<{
+            conflict: "conflict";
+            transport_failure: "transport_failure";
+            boundary_mismatch: "boundary_mismatch";
+            unverified: "unverified";
+            unknown_session: "unknown_session";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strict>]>;
+export type AgentNativeContextContinuationResult = z.infer<typeof AgentNativeContextContinuationResultSchema>;
+/** Runtime-only controls kept outside the digest-bound user turn. */
+export interface AgentNativeContextContinuationOptions {
+    turn: NativeContextContinuationTurn;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+/** Cross-check a successful native continuation against its retained session. */
+export declare function agentNativeContextContinuationResultMatchesRequest(request: NativeContextContinuationRequest, outcome: AgentNativeContextContinuationResult): boolean;
+export interface AgentSessionRef {
+    id: string;
+    provider?: string;
+    controlRef?: AgentRunControlRef;
+    contextTransferReceipt?: ContextTransferReceipt;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentEnvironmentEvent {
+    type: string;
+    data: Record<string, unknown>;
+    id?: string;
+    normalized?: StreamEvent;
+    usage?: TokenUsage;
+    providerEvent?: unknown;
+}
+export interface AgentSession {
+    readonly id: string;
+    readonly controlRef?: AgentRunControlRef;
+    status(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentSessionStatus | null>;
+    events(options?: {
+        /** Exclusive stable event id previously emitted by this session. */
+        since?: string;
+        /** Provider execution selected by the durable control reference, when required. */
+        executionId?: string;
+        signal?: AbortSignal;
+    }): AsyncIterable<AgentEnvironmentEvent>;
+    result(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentTurnResult>;
+    prompt(input: AgentTurnInput): Promise<AgentTurnResult>;
+    respondToInteraction?(command: InteractionResponseCommand, options?: {
+        signal?: AbortSignal;
+    }): Promise<InteractionAcknowledgement>;
+    contextBoundary?(options?: {
+        signal?: AbortSignal;
+    }): Promise<NativeContextBoundaryProof | null>;
+    continueNative?(request: NativeContextContinuationRequest, options: AgentNativeContextContinuationOptions): Promise<AgentNativeContextContinuationResult>;
+    cancelRun?(request: AgentRunCancellationRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentRunCancellationAcknowledgement>;
+    cancel(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export interface AgentEnvironment {
+    readonly id: string;
+    readonly provider: string;
+    readonly name?: string;
+    status(options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentEnvironmentStatus>;
+    stream(input: AgentTurnInput): AsyncIterable<AgentEnvironmentEvent>;
+    dispatch?(input: AgentTurnInput): Promise<AgentSessionRef>;
+    session?(id: string, options?: {
+        controlRef?: AgentRunControlRef;
+        signal?: AbortSignal;
+    }): AgentSession;
+    respondToInteraction?(command: InteractionResponseCommand, options?: {
+        signal?: AbortSignal;
+    }): Promise<InteractionAcknowledgement>;
+    read?(path: string, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<string>;
+    write?(path: string, content: string, options?: {
+        sessionId?: string;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    exec?(command: string, options?: ExecRequest): Promise<ExecResult>;
+    checkpoint?(options?: CheckpointRequest & {
+        signal?: AbortSignal;
+    }): Promise<CheckpointRef>;
+    fork?(checkpoint: CheckpointRef, options?: ForkRequest & {
+        signal?: AbortSignal;
+    }): Promise<AgentEnvironment>;
+    /** Durable, retry-safe checkpoint and environment-fork operations. */
+    readonly workspaceBranching?: AgentWorkspaceBranching;
+    placement?(options?: {
+        signal?: AbortSignal;
+    }): Promise<PlacementInfo>;
+    refresh?(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    destroy?(options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+export interface AgentEnvironmentCapabilities {
+    profile: AgentProfileCapabilities;
+    streaming: {
+        live: boolean;
+        replay: boolean;
+        detach: boolean;
+        turnIdempotency: boolean;
+    };
+    sessions: {
+        continue: boolean;
+        list: boolean;
+        messages: boolean;
+    };
+    /** Present only when retained-run identity and cancellation are complete. */
+    retainedControl?: {
+        exactRunIdentity: boolean;
+        resultIdentity: boolean;
+        eventIdentity: boolean;
+        cancellationIdempotency: boolean;
+    };
+    /** Present only when same-session continuation is atomic and retry-safe. */
+    nativeContinuation?: {
+        atomicBoundary: boolean;
+        requestIdempotency: boolean;
+    };
+    /** Absent when the provider cannot originate or answer interactions. */
+    interactions?: InteractionCapabilities;
+    workspace: {
+        read: boolean;
+        write: boolean;
+        exec: boolean;
+        git: boolean;
+        upload: boolean;
+        download: boolean;
+    };
+    branching: {
+        checkpoint: boolean;
+        fork: boolean;
+        /** True only when key + canonical request digest semantics are implemented. */
+        retrySafe?: boolean;
+        /** True only when operations can be recovered by idempotency key. */
+        lookup?: boolean;
+        /** True only when checkpoints and forked environments have confirmed cleanup. */
+        cleanup?: boolean;
+    };
+    placement: boolean;
+    usage: boolean;
+    confidential: boolean;
+    /** Present only when {@link AgentEnvironmentProvider.exactProcess} is implemented. */
+    exactProcess?: {
+        egress: readonly AgentExactProcessEgressMode[];
+    };
+}
+/** Strict runtime validator for provider capability negotiation. */
+export declare const AgentEnvironmentCapabilitiesSchema: z.ZodObject<{
+    profile: z.ZodObject<{
+        namedProfiles: z.ZodBoolean;
+        systemPrompt: z.ZodObject<{
+            replace: z.ZodBoolean;
+            append: z.ZodBoolean;
+        }, z.core.$strict>;
+        instructions: z.ZodBoolean;
+        tools: z.ZodBoolean;
+        permissions: z.ZodBoolean;
+        mcp: z.ZodBoolean;
+        subagents: z.ZodBoolean;
+        resources: z.ZodObject<{
+            files: z.ZodBoolean;
+            instructions: z.ZodBoolean;
+            tools: z.ZodOptional<z.ZodBoolean>;
+            skills: z.ZodOptional<z.ZodBoolean>;
+            agents: z.ZodOptional<z.ZodBoolean>;
+            commands: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        hooks: z.ZodOptional<z.ZodBoolean>;
+        modes: z.ZodOptional<z.ZodBoolean>;
+        runtimeUpdate: z.ZodBoolean;
+        validation: z.ZodBoolean;
+        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    streaming: z.ZodObject<{
+        live: z.ZodBoolean;
+        replay: z.ZodBoolean;
+        detach: z.ZodBoolean;
+        turnIdempotency: z.ZodBoolean;
+    }, z.core.$strict>;
+    sessions: z.ZodObject<{
+        continue: z.ZodBoolean;
+        list: z.ZodBoolean;
+        messages: z.ZodBoolean;
+    }, z.core.$strict>;
+    retainedControl: z.ZodOptional<z.ZodObject<{
+        exactRunIdentity: z.ZodBoolean;
+        resultIdentity: z.ZodBoolean;
+        eventIdentity: z.ZodBoolean;
+        cancellationIdempotency: z.ZodBoolean;
+    }, z.core.$strict>>;
+    nativeContinuation: z.ZodOptional<z.ZodObject<{
+        atomicBoundary: z.ZodBoolean;
+        requestIdempotency: z.ZodBoolean;
+    }, z.core.$strict>>;
+    interactions: z.ZodOptional<z.ZodObject<{
+        kinds: z.ZodArray<z.ZodString>;
+        answerFieldTypes: z.ZodArray<z.ZodEnum<{
+            number: "number";
+            boolean: "boolean";
+            text: "text";
+            select: "select";
+            secret: "secret";
+        }>>;
+        responseScopes: z.ZodArray<z.ZodEnum<{
+            interaction: "interaction";
+            session: "session";
+            persistent: "persistent";
+        }>>;
+        secretAnswers: z.ZodBoolean;
+        concurrentRequests: z.ZodBoolean;
+        replay: z.ZodBoolean;
+        responseIdempotency: z.ZodBoolean;
+    }, z.core.$strict>>;
+    workspace: z.ZodObject<{
+        read: z.ZodBoolean;
+        write: z.ZodBoolean;
+        exec: z.ZodBoolean;
+        git: z.ZodBoolean;
+        upload: z.ZodBoolean;
+        download: z.ZodBoolean;
+    }, z.core.$strict>;
+    branching: z.ZodObject<{
+        checkpoint: z.ZodBoolean;
+        fork: z.ZodBoolean;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        lookup: z.ZodOptional<z.ZodBoolean>;
+        cleanup: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    placement: z.ZodBoolean;
+    usage: z.ZodBoolean;
+    confidential: z.ZodBoolean;
+    exactProcess: z.ZodOptional<z.ZodObject<{
+        egress: z.ZodArray<z.ZodEnum<{
+            blocked: "blocked";
+            strict: "strict";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export interface CreateAgentEnvironmentInput {
+    profile: AgentProfileRef;
+    /** Agent backend inside the provider, for example "opencode" or "codex". */
+    backend?: string;
+    workspace?: WorkspaceRequest;
+    resources?: ResourceRequest;
+    env?: Record<string, string>;
+    secrets?: string[] | Record<string, string>;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    idempotencyKey?: string;
+    signal?: AbortSignal;
+    providerOptions?: Record<string, unknown>;
+}
+export interface AgentEnvironmentProvider {
+    readonly name: string;
+    readonly exactProcess?: AgentExactProcessProvider;
+    capabilities(): AgentEnvironmentCapabilities | Promise<AgentEnvironmentCapabilities>;
+    validateProfile?(profile: AgentProfileRef): AgentProfileValidationResult | Promise<AgentProfileValidationResult>;
+    create(input: CreateAgentEnvironmentInput): Promise<AgentEnvironment>;
+    get?(id: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentEnvironment | null>;
+    list?(query?: AgentEnvironmentQuery, options?: {
+        signal?: AbortSignal;
+    }): Promise<AgentEnvironmentSummary[]>;
+}