@tangle-network/agent-interface 0.45.0 → 0.46.1

package/dist/runtime-control.js

@@ -1,12 +1,9 @@
 import { z } from "zod";
 import { canonicalCandidateDigest, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+import { boundedIdentifierSchema, boundedJsonRecordSchema, boundedJsonSchema, boundedStringSchema, } from "./contract-limits.js";
 import { InteractionRequestSchema } from "./interaction.js";
 import { DurablePlanSchema } from "./plan.js";
-const stableIdSchema = z
-    .string()
-    .min(1)
-    .max(512)
-    .refine((value) => value.trim() === value, "identifier cannot have outer whitespace");
+const stableIdSchema = boundedIdentifierSchema;
 export const AgentRunControlRefSchema = z.strictObject({
     runId: stableIdSchema,
     provider: stableIdSchema,
@@ -15,22 +12,32 @@ export const AgentRunControlRefSchema = z.strictObject({
     executionId: stableIdSchema.optional(),
     requestDigest: sha256DigestSchema.optional(),
 });
+export const AgentExactRunControlRefSchema = AgentRunControlRefSchema.extend({
+    sessionId: stableIdSchema,
+    executionId: stableIdSchema,
+    requestDigest: sha256DigestSchema,
+});
 export function agentRunCancellationRequestDigest(request) {
+    const parsed = AgentRunCancellationRequestMaterialSchema.parse(request);
     return canonicalCandidateDigest({
-        operationId: request.operationId,
-        run: AgentRunControlRefSchema.parse(request.run),
-        ...(request.reason === undefined ? {} : { reason: request.reason }),
+        operationId: parsed.operationId,
+        run: parsed.run,
+        ...(parsed.reason === undefined ? {} : { reason: parsed.reason }),
     });
 }
+const AgentRunCancellationRequestMaterialSchema = z.strictObject({
+    operationId: stableIdSchema,
+    run: AgentExactRunControlRefSchema,
+    reason: boundedStringSchema.min(1).max(2_048).optional(),
+});
 export const AgentRunCancellationRequestSchema = z
     .strictObject({
-    operationId: stableIdSchema,
+    ...AgentRunCancellationRequestMaterialSchema.shape,
     requestDigest: sha256DigestSchema,
-    run: AgentRunControlRefSchema,
-    reason: z.string().min(1).max(2_048).optional(),
 })
     .superRefine((request, refinement) => {
-    if (request.requestDigest !== agentRunCancellationRequestDigest(request)) {
+    const { requestDigest: _requestDigest, ...material } = request;
+    if (request.requestDigest !== agentRunCancellationRequestDigest(material)) {
         refinement.addIssue({
             code: "custom",
             path: ["requestDigest"],
@@ -42,22 +49,59 @@ export const AgentRunCancellationAcknowledgementSchema = z
     .strictObject({
     operationId: stableIdSchema,
     requestDigest: sha256DigestSchema,
-    run: AgentRunControlRefSchema,
+    run: AgentExactRunControlRefSchema,
     status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
     effect: z.enum(["cancel_requested", "cancelled", "not_live", "unknown"]),
-    message: z.string().min(1).optional(),
+    message: boundedStringSchema.min(1).optional(),
     retryable: z.boolean().optional(),
+    existingRequestDigest: sha256DigestSchema.optional(),
 })
     .superRefine((acknowledgement, refinement) => {
     const known = acknowledgement.effect !== "unknown";
-    if (((acknowledgement.status === "accepted" || acknowledgement.status === "replayed") && !known) ||
-        ((acknowledgement.status === "conflict" || acknowledgement.status === "unknown") && known)) {
+    if (((acknowledgement.status === "accepted" ||
+        acknowledgement.status === "replayed") &&
+        !known) ||
+        ((acknowledgement.status === "conflict" ||
+            acknowledgement.status === "unknown") &&
+            known)) {
         refinement.addIssue({
             code: "custom",
             path: ["effect"],
             message: "cancellation status and effect certainty do not agree",
         });
     }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a cancellation conflict must include the existing digest",
+        });
+    }
+    if (acknowledgement.status === "conflict" &&
+        acknowledgement.existingRequestDigest === acknowledgement.requestDigest) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a cancellation conflict must identify a different request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only a cancellation conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.status === "unknown" &&
+        (acknowledgement.message === undefined || acknowledgement.retryable !== false)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "an unknown cancellation outcome must be explicit and non-repeatable",
+        });
+    }
 });
 export function agentRunCancellationAcknowledgementMatchesRequest(request, acknowledgement) {
     const exactRequest = AgentRunCancellationRequestSchema.safeParse(request);
@@ -69,7 +113,84 @@ export function agentRunCancellationAcknowledgementMatchesRequest(request, ackno
         canonicalCandidateDigest(exactAcknowledgement.data.run) ===
             canonicalCandidateDigest(exactRequest.data.run));
 }
-const unknownRecordSchema = z.record(z.string(), z.unknown());
+export function agentRunControlRequestDigest(request) {
+    const parsed = AgentRunControlRequestMaterialSchema.parse(request);
+    return canonicalCandidateDigest({
+        operationId: parsed.operationId,
+        action: parsed.action,
+        run: parsed.run,
+        ...(parsed.payload === undefined ? {} : { payload: parsed.payload }),
+    });
+}
+const AgentRunControlRequestMaterialSchema = z.strictObject({
+    operationId: stableIdSchema,
+    action: z.enum(["steer", "cancel", "status", "reconnect"]),
+    run: AgentExactRunControlRefSchema,
+    payload: boundedJsonRecordSchema.optional(),
+});
+export const AgentRunControlRequestSchema = z
+    .strictObject({
+    ...AgentRunControlRequestMaterialSchema.shape,
+    requestDigest: sha256DigestSchema,
+})
+    .superRefine((request, refinement) => {
+    const { requestDigest: _requestDigest, ...material } = request;
+    if (request.requestDigest !== agentRunControlRequestDigest(material)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["requestDigest"],
+            message: "run control request digest does not match its content",
+        });
+    }
+});
+export const AgentRunControlAcknowledgementSchema = z
+    .strictObject({
+    operationId: stableIdSchema,
+    requestDigest: sha256DigestSchema,
+    run: AgentExactRunControlRefSchema,
+    status: z.enum(["accepted", "replayed", "conflict", "unknown"]),
+    message: boundedStringSchema.min(1).optional(),
+    retryable: z.boolean().optional(),
+    existingRequestDigest: sha256DigestSchema.optional(),
+})
+    .superRefine((acknowledgement, refinement) => {
+    if (acknowledgement.status === "conflict" &&
+        (acknowledgement.existingRequestDigest === undefined ||
+            acknowledgement.existingRequestDigest === acknowledgement.requestDigest)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "a control conflict must identify a different existing request",
+        });
+    }
+    if (acknowledgement.status !== "conflict" &&
+        acknowledgement.existingRequestDigest !== undefined) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["existingRequestDigest"],
+            message: "only a control conflict may include an existing digest",
+        });
+    }
+    if (acknowledgement.status === "unknown" &&
+        (acknowledgement.message === undefined || acknowledgement.retryable !== false)) {
+        refinement.addIssue({
+            code: "custom",
+            path: ["retryable"],
+            message: "an unknown control outcome must be explicit and non-repeatable",
+        });
+    }
+});
+export function agentRunControlAcknowledgementMatchesRequest(request, acknowledgement) {
+    const exactRequest = AgentRunControlRequestSchema.safeParse(request);
+    const exactAcknowledgement = AgentRunControlAcknowledgementSchema.safeParse(acknowledgement);
+    if (!exactRequest.success || !exactAcknowledgement.success)
+        return false;
+    return (exactAcknowledgement.data.operationId === exactRequest.data.operationId &&
+        exactAcknowledgement.data.requestDigest === exactRequest.data.requestDigest &&
+        canonicalCandidateDigest(exactAcknowledgement.data.run) ===
+            canonicalCandidateDigest(exactRequest.data.run));
+}
+const unknownRecordSchema = boundedJsonRecordSchema;
 const partBase = {
     id: stableIdSchema,
     sessionID: stableIdSchema,
@@ -83,20 +204,20 @@ const toolStateSchema = z.discriminatedUnion("status", [
     z.strictObject({
         status: z.literal("pending"),
         input: unknownRecordSchema,
-        raw: z.string().optional(),
+        raw: boundedStringSchema.optional(),
     }),
     z.strictObject({
         status: z.literal("running"),
         input: unknownRecordSchema,
-        title: z.string().optional(),
+        title: boundedStringSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: z.strictObject({ start: z.number().finite() }).optional(),
     }),
     z.strictObject({
         status: z.literal("completed"),
         input: unknownRecordSchema,
-        output: z.unknown(),
-        title: z.string().optional(),
+        output: boundedJsonSchema,
+        title: boundedStringSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: z.strictObject({
             start: z.number().finite(),
@@ -106,14 +227,14 @@ const toolStateSchema = z.discriminatedUnion("status", [
     z.strictObject({
         status: z.enum(["error", "failed"]),
         input: unknownRecordSchema,
-        error: z.string().optional(),
-        output: z.unknown().optional(),
+        error: boundedStringSchema.optional(),
+        output: boundedJsonSchema.optional(),
         metadata: unknownRecordSchema.optional(),
         time: toolTimeSchema.optional(),
     }),
 ]);
 const partSchema = z.discriminatedUnion("type", [
-    z.strictObject({ ...partBase, type: z.literal("text"), text: z.string() }),
+    z.strictObject({ ...partBase, type: z.literal("text"), text: boundedStringSchema }),
     z.strictObject({
         ...partBase,
         type: z.literal("tool"),
@@ -125,20 +246,20 @@ const partSchema = z.discriminatedUnion("type", [
     z.strictObject({
         ...partBase,
         type: z.literal("reasoning"),
-        text: z.string(),
+        text: boundedStringSchema,
     }),
     z.strictObject({
         ...partBase,
         type: z.literal("file"),
-        filename: z.string().optional(),
-        mediaType: z.string().optional(),
-        url: z.string().optional(),
+        filename: boundedStringSchema.optional(),
+        mediaType: boundedStringSchema.optional(),
+        url: boundedStringSchema.optional(),
     }),
     z.strictObject({
         ...partBase,
         type: z.literal("subtask"),
-        prompt: z.string(),
-        description: z.string(),
+        prompt: boundedStringSchema,
+        description: boundedStringSchema,
         agent: stableIdSchema,
     }),
 ]);
@@ -147,7 +268,7 @@ export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("message.part.updated"),
         part: partSchema,
-        delta: z.string().optional(),
+        delta: boundedStringSchema.optional(),
     }),
     z.strictObject({
         type: z.literal("tool-heartbeat"),
@@ -171,22 +292,22 @@ export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("status"),
         status: z.enum(["started", "processing", "completed", "failed"]),
-        detail: z.string().optional(),
+        detail: boundedStringSchema.optional(),
     }),
     z.strictObject({
         type: z.literal("warning"),
         code: stableIdSchema,
-        message: z.string(),
+        message: boundedStringSchema,
     }),
     z.strictObject({
         type: z.literal("raw"),
         backend: stableIdSchema,
-        event: z.unknown(),
+        event: boundedJsonSchema,
     }),
     z.strictObject({
         type: z.literal("session.updated"),
         sessionId: stableIdSchema,
-        title: z.string().optional(),
+        title: boundedStringSchema.optional(),
         time: z.strictObject({
             created: z.number().finite().optional(),
             updated: z.number().finite().optional(),
@@ -199,7 +320,7 @@ export const CanonicalStreamEventSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("interaction.cancel"),
         id: stableIdSchema,
-        reason: z.string().optional(),
+        reason: boundedStringSchema.optional(),
     }),
     z.strictObject({
         type: z.literal("plan.submitted"),
@@ -211,7 +332,7 @@ export const RuntimeEventEnvelopeSchema = z.strictObject({
     eventId: stableIdSchema,
     sequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
     cursor: stableIdSchema.optional(),
-    occurredAt: z.iso.datetime().optional(),
-    receivedAt: z.iso.datetime(),
+    occurredAt: z.iso.datetime().max(64).optional(),
+    receivedAt: z.iso.datetime().max(64),
     event: CanonicalStreamEventSchema,
 });

package/dist/stream-events.d.ts

@@ -0,0 +1,55 @@
+import type { InteractionRequest } from "./interaction.js";
+import type { DurablePlan } from "./plan.js";
+import type { Part } from "./parts.js";
+export type MessagePartUpdatedEvent = {
+    type: "message.part.updated";
+    part: Part;
+    delta?: string;
+};
+export type StreamEvent = MessagePartUpdatedEvent | {
+    type: "tool-heartbeat";
+    toolName: string;
+    partId: string;
+    elapsedMs: number;
+} | {
+    type: "tool-slow";
+    toolName: string;
+    partId: string;
+    elapsedMs: number;
+    thresholdMs: number;
+} | {
+    type: "model-processing";
+    phase: "tool-result" | "generating" | "thinking";
+    toolName?: string;
+    elapsedMs?: number;
+} | {
+    type: "status";
+    status: "started" | "processing" | "completed" | "failed";
+    detail?: string;
+} | {
+    type: "warning";
+    code: string;
+    message: string;
+} | {
+    type: "raw";
+    backend: string;
+    event: unknown;
+} | {
+    type: "session.updated";
+    sessionId: string;
+    title?: string;
+    time?: {
+        created?: number;
+        updated?: number;
+    };
+} | {
+    type: "interaction";
+    request: InteractionRequest;
+} | {
+    type: "interaction.cancel";
+    id: string;
+    reason?: string;
+} | {
+    type: "plan.submitted";
+    plan: DurablePlan;
+};

package/dist/stream-events.js

@@ -0,0 +1 @@
+export {};

package/dist/workspace-branching-shared.d.ts

@@ -0,0 +1,7 @@
+import type { Sha256Digest } from "./agent-candidate.js";
+import { sha256DigestSchema } from "./agent-candidate-schema-common.js";
+export { sha256DigestSchema };
+export declare const idSchema: import("zod").ZodString;
+export declare const jsonRecordSchema: import("zod").ZodCustom<Record<string, unknown>, Record<string, unknown>>;
+export declare function wireDigest(value: unknown): Sha256Digest;
+export declare function sameOptionalWireValue(left: unknown, right: unknown): boolean;

package/dist/workspace-branching-shared.js

@@ -0,0 +1,20 @@
+import { canonicalCandidateDigest, sha256DigestSchema } from "./agent-candidate-schema-common.js";
+import { assertBoundedSerializedJson, boundedIdentifierSchema, boundedJsonRecordSchema, isBoundedJsonMaterial, } from "./contract-limits.js";
+export { sha256DigestSchema };
+export const idSchema = boundedIdentifierSchema;
+export const jsonRecordSchema = boundedJsonRecordSchema;
+export function wireDigest(value) {
+    if (!isBoundedJsonMaterial(value)) {
+        throw new Error("operation material exceeds the contract bounds");
+    }
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw new Error("operation material must be JSON serializable");
+    assertBoundedSerializedJson(serialized);
+    return canonicalCandidateDigest(JSON.parse(serialized));
+}
+export function sameOptionalWireValue(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return wireDigest(left) === wireDigest(right);
+}

package/dist/workspace-branching.d.ts

@@ -1,254 +1,4 @@
-import { z } from "zod";
-import type { Sha256Digest } from "./agent-candidate.js";
-import type { PlacementInfo } from "./environment-provider.js";
-import { type AgentRunControlRef } from "./runtime-control.js";
-export interface WorkspaceCheckpointMaterial {
-    source: AgentRunControlRef;
-    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.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>;
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    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: AgentRunControlRef;
-    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.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>;
-    idempotencyKey: z.ZodString;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    createdAt: z.ZodISODateTime;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-}, 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>;
-export interface WorkspaceForkMaterial {
-    checkpoint: WorkspaceCheckpointRef;
-    name?: string;
-    metadata?: Record<string, unknown>;
-}
-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.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>;
-        idempotencyKey: z.ZodString;
-        requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-        createdAt: z.ZodISODateTime;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    }, z.core.$strict>;
-    name: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    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;
-    sourceCheckpointId: string;
-    idempotencyKey: string;
-    requestDigest: Sha256Digest;
-    createdAt: string;
-    placement?: PlacementInfo;
-    confidential: boolean;
-    metadata?: Record<string, unknown>;
-}
-export declare const ForkedEnvironmentRefSchema: z.ZodObject<{
-    provider: z.ZodString;
-    environmentId: z.ZodString;
-    sourceCheckpointId: z.ZodString;
-    idempotencyKey: z.ZodString;
-    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-    createdAt: z.ZodISODateTime;
-    placement: z.ZodOptional<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.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-    }, z.core.$strict>>;
-    confidential: z.ZodBoolean;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-}, z.core.$strict>;
-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 const WorkspaceCleanupRequestSchema: z.ZodObject<{
-    operationId: z.ZodString;
-    targetId: z.ZodString;
-    provider: z.ZodString;
-}, z.core.$strict>;
-export type WorkspaceCleanupRequest = z.infer<typeof WorkspaceCleanupRequestSchema>;
-export declare const WorkspaceCleanupAcknowledgementSchema: z.ZodObject<{
-    operationId: z.ZodString;
-    targetId: z.ZodString;
-    provider: z.ZodString;
-    status: z.ZodEnum<{
-        unknown: "unknown";
-        conflict: "conflict";
-        transport_failure: "transport_failure";
-        deleted: "deleted";
-        already_absent: "already_absent";
-        in_use: "in_use";
-    }>;
-    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, options?: {
-        signal?: AbortSignal;
-    }): Promise<WorkspaceCleanupAcknowledgement>;
-    fork(request: WorkspaceForkRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<WorkspaceForkResult>;
-    lookupFork(request: WorkspaceOperationLookupRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<WorkspaceForkLookupResult>;
-    destroyFork(request: WorkspaceCleanupRequest, options?: {
-        signal?: AbortSignal;
-    }): Promise<WorkspaceCleanupAcknowledgement>;
-}
-/** Bind a checkpoint result to the exact request before using the resource. */
-export declare function workspaceCheckpointResultMatchesRequest(request: WorkspaceCheckpointRequest, result: WorkspaceCheckpointResult | WorkspaceCheckpointLookupResult): boolean;
-/** Bind a fork result to the exact checkpoint request before using it. */
-export declare function workspaceForkResultMatchesRequest(request: WorkspaceForkRequest, result: WorkspaceForkResult | WorkspaceForkLookupResult): boolean;
-/** Bind cleanup confirmation to the exact provider resource and operation. */
-export declare function workspaceCleanupAcknowledgementMatches(request: WorkspaceCleanupRequest, acknowledgement: WorkspaceCleanupAcknowledgement): boolean;
+export * from "./workspace-confidentiality.js";
+export * from "./workspace-checkpoint.js";
+export * from "./workspace-fork.js";
+export * from "./workspace-cleanup.js";