qlogicagent 2.3.0 → 2.5.0

package/dist/types/protocol/wire/capability-manifest.d.ts

@@ -0,0 +1,111 @@
+import type { WebActionScope, WebApprovalDefault, WebCapabilityDescriptorContract, WebCapabilityFamily, WebCapabilityId, WebDegradationTarget, WebEscalationReason, WebExecutionMode, WebPolicyRiskClass, WebRetryPolicy, WebStatefulness, WebTaskMode } from "./web-capability.js";
+import type { ApprovalRequiredToolContract } from "./session.js";
+export declare const CAPABILITY_MANIFEST_DIFF_SECTIONS: readonly ["gatewayVersion", "toolNamespaces", "workspaceIds", "installedCapabilities", "enabledCapabilities", "features", "approvalMode", "toolManifests", "skillManifests", "pluginManifests", "mcpManifests", "approvalPolicy", "workspaceSummaries"];
+export type CapabilityManifestDiffSection = (typeof CAPABILITY_MANIFEST_DIFF_SECTIONS)[number];
+export type CapabilityManifestApprovalMode = "user-confirm" | "pre-authorized";
+export type CapabilityToolManifestContract = WebCapabilityDescriptorContract & {
+    name: string;
+    label: string;
+    description: string;
+    source: "core" | "plugin";
+    capabilityId?: WebCapabilityId;
+    capabilityFamily?: WebCapabilityFamily;
+    taskMode?: WebTaskMode;
+    executionMode?: WebExecutionMode;
+    statefulness?: WebStatefulness;
+    approvalDefault?: WebApprovalDefault;
+    policyRiskClass?: WebPolicyRiskClass;
+    allowedActionScopes?: WebActionScope[];
+    degradationTarget?: WebDegradationTarget;
+    upgradeTargets?: WebCapabilityId[];
+    escalationReasons?: WebEscalationReason[];
+    retryPolicy?: WebRetryPolicy;
+    [key: string]: unknown;
+};
+export type CapabilitySkillManifestContract = {
+    name: string;
+    description: string;
+    source: string;
+    eligible: boolean;
+    disabled: boolean;
+    [key: string]: unknown;
+};
+export type CapabilityPluginManifestContract = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "loaded" | "disabled" | "error";
+    [key: string]: unknown;
+};
+export type CapabilityMcpManifestContract = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "connected" | "disconnected" | "error";
+    [key: string]: unknown;
+};
+export interface CapabilityManifestApprovalPolicyContract {
+    mode: CapabilityManifestApprovalMode;
+    execApprovalsConfigured: boolean;
+}
+export interface CapabilityWorkspaceSummaryContract {
+    id: string;
+    role?: string;
+}
+export interface CapabilityManifestSnapshotContract {
+    snapshotVersion: string;
+    updatedAt: string;
+    syncMode?: "full" | "diff";
+    baseSnapshotVersion?: string;
+    changedSections?: CapabilityManifestDiffSection[];
+    gatewayVersion?: string;
+    toolNamespaces: string[];
+    workspaceIds: string[];
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+    features?: string[];
+    approvalMode?: CapabilityManifestApprovalMode;
+    toolManifests?: CapabilityToolManifestContract[];
+    skillManifests?: CapabilitySkillManifestContract[];
+    pluginManifests?: CapabilityPluginManifestContract[];
+    mcpManifests?: CapabilityMcpManifestContract[];
+    approvalPolicy?: CapabilityManifestApprovalPolicyContract;
+    workspaceSummaries?: CapabilityWorkspaceSummaryContract[];
+}
+export interface HostCapabilitySnapshotContract extends CapabilityManifestSnapshotContract {
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+}
+export type ToolEligibilityStatus = "installed-disabled" | "installed-awaiting-approval" | "installed-ineligible-context" | "enabled-eligible" | "blocked-by-policy" | "unreachable-runtime";
+export type ToolEligibilityReasonCode = "host_disabled" | "approval_required" | "policy_blocked" | "context_mismatch" | "runtime_unreachable" | "not_installed";
+export type ToolEligibilityResolvedSource = "host-capability" | "plugin-manifest" | "mcp-manifest" | "policy" | "runtime-context";
+export interface RuntimeToolEligibilityContract {
+    toolName: string;
+    status: ToolEligibilityStatus;
+    approvalRequired: boolean;
+    reasonCodes: ToolEligibilityReasonCode[];
+    eligibilityReason?: ToolEligibilityReasonCode;
+    policyBlocked?: boolean;
+    contextEligible?: boolean;
+    resolvedSource?: ToolEligibilityResolvedSource;
+    hostLocalOnly?: boolean;
+}
+export interface RuntimeCapabilityViewContract {
+    snapshotVersion: string;
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleTools: RuntimeToolEligibilityContract[];
+    ineligibleTools: RuntimeToolEligibilityContract[];
+    approvalRequiredTools?: ApprovalRequiredToolContract[];
+}
+export declare function cloneCapabilityManifestSnapshot<T extends CapabilityManifestSnapshotContract>(snapshot: T): T;
+export declare function mergeCapabilityManifestSnapshot(params: {
+    previous?: CapabilityManifestSnapshotContract | null;
+    update: CapabilityManifestSnapshotContract;
+}): CapabilityManifestSnapshotContract;
+export declare function deriveCapabilityToolNamespaces(toolManifests: ReadonlyArray<Pick<CapabilityToolManifestContract, "name">>): string[];
+export declare function deriveCapabilityWorkspaceIds(workspaceSummaries: ReadonlyArray<Pick<CapabilityWorkspaceSummaryContract, "id">>): string[];
+export declare function createCapabilityManifestDiffPayload<T extends CapabilityManifestSnapshotContract>(params: {
+    previous?: T | null;
+    current: T;
+}): T | null;

package/dist/types/protocol/wire/capability-transport.d.ts

@@ -0,0 +1,207 @@
+import type { ProxyKeySource } from "./transport.js";
+import type { MemoryContextBlock } from "./memory-provider-lifecycle.js";
+import type { WebCapabilityFamily, WebTaskMode, WebExecutionMode, WebStatefulness, WebPolicyRiskClass } from "./web-capability.js";
+export interface TransportCapabilitySummaryContract {
+    snapshotVersion: string;
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleToolCount?: number;
+    ineligibleToolCount?: number;
+}
+export interface TransportApprovalRequiredToolHintEntry {
+    toolName: string;
+    reasonCodes?: string[];
+}
+export interface TransportToolEligibilitySummaryEntry {
+    toolName: string;
+    status: string;
+    approvalRequired: boolean;
+    reasonCodes?: string[];
+    eligibilityReason?: string;
+    policyBlocked?: boolean;
+    contextEligible?: boolean;
+    resolvedSource?: string;
+}
+export interface CapabilityInstallStateSummary {
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+}
+export interface CapabilityPolicyHintEntry {
+    code: string;
+    scope?: string;
+    message?: string;
+}
+export interface AgentTurnRequestSpec {
+    modality?: "text" | "image" | "video" | "audio" | "music";
+    params?: Record<string, unknown>;
+}
+export interface AgentTurnLocalContext {
+    capabilitySnapshotVersion?: string;
+    toolNamespaces?: string[];
+    workspaceIds?: string[];
+    capabilitySummary?: TransportCapabilitySummaryContract;
+    approvalRequiredToolHint?: TransportApprovalRequiredToolHintEntry[];
+    eligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    ineligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    memoryContextBlocks?: MemoryContextBlock[];
+}
+export interface AgentTurnClientHints {
+    uiSurface?: string;
+    locale?: string;
+}
+export interface AgentTurnAttachment {
+    id?: string;
+    type?: string;
+    mimeType?: string;
+    url?: string;
+    name?: string;
+}
+export interface AgentTurnConversation {
+    messages: unknown[];
+    attachments?: AgentTurnAttachment[];
+    summary?: string;
+}
+export interface AgentTurnExperience {
+    mode?: string;
+    modelAlias?: string;
+    stream?: boolean;
+    responseFormat?: string;
+    keySource?: ProxyKeySource;
+}
+export interface ToolExecutionStepContext {
+    stepIndex?: number;
+    stepTotal?: number;
+    stepSummary?: string;
+    selectedCapabilityId?: string;
+    selectedCapabilityFamily?: WebCapabilityFamily;
+    selectedTaskMode?: WebTaskMode;
+    displayRiskLabel?: string;
+    displayFallbackLabel?: string;
+    displayBlockedLabel?: string;
+    decisionReasonCode?: string;
+    fallbackPlanRef?: string;
+}
+export interface ToolInvokeApprovalDescriptor extends ToolExecutionStepContext {
+    mode?: "user-confirm" | "pre-authorized";
+    reason?: string;
+}
+export interface CapabilityToolManifestEntry {
+    name: string;
+    label: string;
+    description: string;
+    source: "core" | "plugin";
+    category?: "core" | "media" | "browser" | "session" | "system" | "think";
+    groupId?: string;
+    pluginId?: string;
+    optional?: boolean;
+    defaultProfiles?: string[];
+    requiredParameters?: string[];
+    parametersSummary?: string;
+    riskLevel?: "low" | "medium" | "high";
+    approvalMode?: "user-confirm" | "pre-authorized";
+    requiresApproval?: boolean;
+    parallelSafe?: boolean;
+    serialOnly?: boolean;
+    recoverable?: boolean;
+    resultMode?: "final";
+    capabilityId?: string;
+    capabilityFamily?: WebCapabilityFamily;
+    taskMode?: WebTaskMode;
+    executionMode?: WebExecutionMode;
+    statefulness?: WebStatefulness;
+    approvalDefault?: "required" | "conditional" | "none";
+    policyRiskClass?: WebPolicyRiskClass;
+    requiresRuntimeBackend?: boolean;
+    requiresHostBridge?: boolean;
+    supportsRenderBackend?: boolean;
+    supportsLoginState?: boolean;
+    supportsPersistentProfile?: boolean;
+    supportsSharedSessionReuse?: boolean;
+    supportsTransactionality?: "read-only" | "state-changing";
+    allowedActionScopes?: string[];
+    degradationTarget?: string;
+    upgradeTargets?: string[];
+    fallbackChain?: string[];
+    escalationReasons?: string[];
+    auditRequired?: boolean;
+    requiresUserVisibleStep?: boolean;
+    retryPolicy?: "none" | "same-capability-once" | "degrade-only";
+    repairAfterDenied?: boolean;
+    repairAfterUnavailable?: boolean;
+    displayRiskLabel?: string;
+    displayBlockedLabel?: string;
+    displayFallbackLabel?: string;
+}
+export interface CapabilitySkillManifestEntry {
+    name: string;
+    description: string;
+    source: string;
+    eligible: boolean;
+    disabled: boolean;
+    category?: string;
+    installable?: boolean;
+}
+export interface CapabilityPluginManifestEntry {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+    kind?: string;
+    origin?: string;
+    enabled: boolean;
+    status: "loaded" | "disabled" | "error";
+    error?: string;
+    hasConfigSchema?: boolean;
+    capabilityFlags?: string[];
+}
+export interface CapabilityMcpManifestEntry {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "connected" | "disconnected" | "error";
+    serverKind?: string;
+    tools?: string[];
+}
+export interface CapabilityApprovalPolicy {
+    mode: "user-confirm" | "pre-authorized";
+    execApprovalsConfigured: boolean;
+}
+export interface CapabilityWorkspaceSummary {
+    id: string;
+    role?: string;
+}
+export interface CapabilitySyncPayload {
+    snapshotVersion: string;
+    updatedAt: string;
+    syncMode?: "full" | "diff";
+    baseSnapshotVersion?: string;
+    changedSections?: string[];
+    gatewayVersion?: string;
+    toolNamespaces: string[];
+    workspaceIds: string[];
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+    features?: string[];
+    approvalMode?: "user-confirm" | "pre-authorized";
+    toolManifests?: CapabilityToolManifestEntry[];
+    skillManifests?: CapabilitySkillManifestEntry[];
+    pluginManifests?: CapabilityPluginManifestEntry[];
+    mcpManifests?: CapabilityMcpManifestEntry[];
+    approvalPolicy?: CapabilityApprovalPolicy;
+    policyHints?: CapabilityPolicyHintEntry[];
+    workspaceSummaries?: CapabilityWorkspaceSummary[];
+}
+export interface CapabilitySyncMsg extends CapabilitySyncPayload {
+    type: "capability.sync";
+    id: string;
+}
+export interface CapabilitySyncAckPayload {
+    success: true;
+    snapshotVersion: string;
+    receivedAt: string;
+}
+export interface CapabilitySyncAckMsg {
+    type: "capability.sync.ack";
+    id: string;
+    payload: CapabilitySyncAckPayload;
+}

package/dist/types/protocol/wire/channel-ingress.d.ts

@@ -0,0 +1,29 @@
+export type GatewayChannelExecutionIngressSource = "channel-ingress";
+export type GatewayChannelExecutionEgressKind = "partial" | "final" | "approval" | "error" | "artifact" | "control";
+export interface GatewayChannelExecutionIngressBindingContract {
+    requestId: string;
+    gatewayTargetRef: string;
+    channelRequestId: string;
+    replyTargetRef: string;
+    channelType: string;
+    channelConversationId: string;
+    channelUserId: string;
+    dedupeKey: string;
+    receivedAt: string;
+    source: GatewayChannelExecutionIngressSource;
+}
+export interface GatewayChannelExecutionEgressContract {
+    requestId: string;
+    replyTargetRef: string;
+    channelRequestId?: string;
+    sessionId?: string;
+    turnId?: string;
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    envelopeKind: GatewayChannelExecutionEgressKind;
+    emittedAt: string;
+    terminal: boolean;
+}

package/dist/types/protocol/wire/channel.d.ts

@@ -0,0 +1,89 @@
+export type NormalizedChannelType = "telegram" | "slack" | "whatsapp" | "discord" | "wechat" | "custom";
+export type NormalizedChannelMessagePartType = "text" | "image" | "audio" | "video" | "file" | "location" | "event" | "custom";
+export type NormalizedChannelRetryBackoffPolicy = "fixed" | "exponential" | "provider-managed";
+export type NormalizedChannelIdempotencyScope = "reply-target" | "conversation" | "channel-request";
+export type NormalizedChannelDeliveryStatus = "pending" | "delivered" | "retrying" | "failed" | "expired" | "cancelled";
+export interface NormalizedChannelMessagePart {
+    partType: NormalizedChannelMessagePartType;
+    text?: string;
+    mimeType?: string;
+    assetRef?: string;
+    sizeBytes?: number;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelAttachment {
+    attachmentId: string;
+    mimeType?: string;
+    filename?: string;
+    downloadUrl?: string;
+    assetRef?: string;
+    sizeBytes?: number;
+}
+export interface NormalizedChannelExecutionHints {
+    intent?: string;
+    locale?: string;
+    expectsReply?: boolean;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelDeliveryPolicy {
+    allowEdit?: boolean;
+    allowReplyThread?: boolean;
+    maxRetryCount?: number;
+    retryBackoffPolicy?: NormalizedChannelRetryBackoffPolicy;
+    idempotencyScope?: NormalizedChannelIdempotencyScope;
+}
+export interface NormalizedChannelInboundRequest {
+    channelRequestId: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    channelUserId: string;
+    receivedAt: string;
+    dedupeKey: string;
+    gatewayTargetRef: string;
+    replyTargetRef: string;
+    messageParts: NormalizedChannelMessagePart[];
+    attachments?: NormalizedChannelAttachment[];
+    executionHints?: NormalizedChannelExecutionHints;
+}
+export interface NormalizedChannelReplyTarget {
+    replyTargetRef: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    channelMessageRef?: string;
+    recipientRef: string;
+    threadRef?: string;
+    expiresAt?: string;
+    deliveryPolicy?: NormalizedChannelDeliveryPolicy;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelReplyRequest {
+    deliveryAttemptId: string;
+    replyTargetRef: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    recipientRef: string;
+    threadRef?: string;
+    replyToMessageId: string;
+    gatewayId: string;
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    fileName?: string;
+    mimeType?: string;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelDeliveryOutcome {
+    deliveryAttemptId: string;
+    replyTargetRef: string;
+    deliveryStatus: NormalizedChannelDeliveryStatus;
+    providerMessageRef?: string;
+    providerErrorCode?: string;
+    providerErrorMessage?: string;
+    attemptedAt: string;
+    ackedAt?: string;
+    retryCount: number;
+    nextRetryAt?: string;
+}

package/dist/types/protocol/wire/chat-types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Chat Wire Types — fundamental data types that cross the JSON-RPC boundary.
+ *
+ * These types appear in RPC method params/results (thread.turn, session.resume, etc.)
+ * and are needed by every consumer that interacts with the agent.
+ */
+export type ChatMessageRole = "system" | "user" | "assistant" | "tool";
+/** Thinking block from Anthropic Messages API (DeepSeek, Claude, etc.) */
+export interface ThinkingBlock {
+    thinking: string;
+    signature: string;
+}
+/** Tool call within an assistant message. */
+export interface ToolCallMessage {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/**
+ * Chat message — the fundamental unit of conversation over JSON-RPC.
+ *
+ * Used in `thread.turn` params (user sends messages to agent)
+ * and `session.resume` result (agent returns conversation history).
+ */
+export interface ChatMessage {
+    role: ChatMessageRole;
+    content: string | null;
+    /** For assistant messages with tool calls. */
+    tool_calls?: ToolCallMessage[];
+    /** For tool result messages. */
+    tool_call_id?: string;
+    /** For tool result messages — tool name. */
+    name?: string;
+    /** Anthropic thinking blocks — must be passed back to API in subsequent requests. */
+    thinkingBlocks?: ThinkingBlock[];
+    /** Image URLs for vision-capable models. */
+    imageUrls?: string[];
+    /** Image detail level: 'auto' | 'low' | 'high' | 'xhigh'. */
+    imageDetail?: "auto" | "low" | "high" | "xhigh";
+    /** Max image pixels budget (Volcengine image_pixel_limit). */
+    imagePixelLimit?: {
+        minPixels?: number;
+        maxPixels?: number;
+    };
+    /** Video URLs for video-understanding models. */
+    videoUrls?: string[];
+    /** Per-video fps for video understanding (0.2-5, default 1). */
+    videoFps?: number;
+    /** Audio format hint: 'mp3' | 'wav' | 'aac' | 'm4a'. */
+    audioFormat?: "mp3" | "wav" | "aac" | "m4a";
+    /** Audio URLs for audio-understanding models. */
+    audioUrls?: string[];
+    /** Pre-uploaded file IDs for document/media understanding. */
+    fileIds?: Array<{
+        id: string;
+        mimeType?: string;
+        size?: number;
+    }>;
+}
+/**
+ * Tool definition — wire format as sent over JSON-RPC.
+ *
+ * Used in `thread.turn` params (host provides available tools)
+ * and `tools.list` result (agent reports its tool inventory).
+ */
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters?: Record<string, unknown>;
+    };
+    /** Tool scheduling metadata from host manifest (optional). */
+    meta?: {
+        serialOnly?: boolean;
+        parallelSafe?: boolean;
+        /** If true, host should request user approval before execution. */
+        requiresApproval?: boolean;
+        /** Tool is read-only / safe — skip approval even in strict mode. */
+        isReadOnly?: boolean;
+        /** Tool can cause irreversible side-effects — force approval in default mode. */
+        isDangerous?: boolean;
+    };
+}

package/dist/types/protocol/wire/checkpoint-runtime.d.ts

@@ -0,0 +1,61 @@
+import type { MutationCheckpointContract, MutationCheckpointSnapshotEntryContract, MutationCheckpointPhase, MutationCheckpointRestoreAckContract, MutationCheckpointRestoreContract, MutationCheckpointRollbackResultContract } from "./checkpoint.js";
+type MutationCheckpointStartParams = {
+    runId: string;
+    toolCallId: string;
+    sessionId?: string;
+    toolName: string;
+    actionFingerprint?: string;
+    args?: Record<string, unknown>;
+};
+type MutationCheckpointFinishParams = {
+    runId: string;
+    toolCallId: string;
+    phase: Extract<MutationCheckpointPhase, "captured" | "failed" | "restored">;
+    error?: string;
+};
+interface PersistedMutationCheckpointEntry {
+    relativePath: string;
+    kind: MutationCheckpointSnapshotEntryContract["kind"];
+    sourcePath: string;
+    snapshotPath?: string;
+    snapshotSha256?: string;
+}
+interface PersistedMutationCheckpointRecord extends MutationCheckpointContract {
+    workspaceRoot: string;
+    snapshotDir: string;
+    entries: PersistedMutationCheckpointEntry[];
+    restoreHistory: MutationCheckpointRestoreContract[];
+}
+type MutationCheckpointRestoreOutcome = {
+    restoreAck: MutationCheckpointRestoreAckContract;
+    restored: MutationCheckpointRestoreContract;
+    rollbackResult: MutationCheckpointRollbackResultContract;
+};
+type MutationCheckpointRuntimeRecord = Pick<PersistedMutationCheckpointRecord, "checkpointId" | "sessionId" | "workingDirectory" | "pathHints" | "snapshotSha256" | "snapshotEntryCount">;
+export interface MutationCheckpointRuntimeManager {
+    getCheckpointIdForToolCall(params: {
+        runId: string;
+        toolCallId: string;
+    }): string | null;
+    noteCheckpointStart(params: MutationCheckpointStartParams): Promise<MutationCheckpointContract>;
+    noteCheckpointFinished(params: MutationCheckpointFinishParams): MutationCheckpointContract | null;
+    restoreCheckpoint(params: {
+        checkpointId: string;
+        reason?: string;
+        restoreId?: string;
+    }): Promise<{
+        record: MutationCheckpointRuntimeRecord | null;
+        outcome: MutationCheckpointRestoreOutcome;
+    } | null>;
+}
+export interface MutationCheckpointRuntimeManagerDeps {
+    writeJsonAtomic: (filePath: string, data: unknown, options: {
+        trailingNewline: boolean;
+    }) => Promise<void>;
+    resolveWorkspaceRoot: (workspaceDir?: string) => string;
+    currentWorkingDirectory?: () => string;
+    checkpointStateDir?: string;
+    now?: () => number;
+}
+export declare function createMutationCheckpointRuntimeManager(deps: MutationCheckpointRuntimeManagerDeps): MutationCheckpointRuntimeManager;
+export {};

package/dist/types/protocol/wire/checkpoint.d.ts

@@ -0,0 +1,72 @@
+export declare const MUTATION_CHECKPOINT_PHASE_VALUES: readonly ["pending", "captured", "failed", "restored"];
+export type MutationCheckpointPhase = (typeof MUTATION_CHECKPOINT_PHASE_VALUES)[number];
+export declare const MUTATION_CHECKPOINT_ENTRY_KIND_VALUES: readonly ["file", "directory", "missing"];
+export type MutationCheckpointEntryKind = (typeof MUTATION_CHECKPOINT_ENTRY_KIND_VALUES)[number];
+export declare const MUTATION_CHECKPOINT_BACKEND_VALUES: readonly ["metadata-only", "workspace-copy", "shadow-git"];
+export type MutationCheckpointBackend = (typeof MUTATION_CHECKPOINT_BACKEND_VALUES)[number];
+export interface MutationCheckpointSnapshotEntryContract {
+    relativePath: string;
+    kind: MutationCheckpointEntryKind;
+    snapshotSha256?: string;
+}
+export interface MutationCheckpointContract {
+    checkpointId: string;
+    runId: string;
+    toolCallId?: string;
+    sessionId?: string;
+    toolName: string;
+    actionFingerprint?: string;
+    dedupeKey: string;
+    workingDirectory: string;
+    pathHints: string[];
+    backend: MutationCheckpointBackend;
+    phase: MutationCheckpointPhase;
+    snapshotSha256: string;
+    snapshotEntryCount: number;
+    snapshotEntries: MutationCheckpointSnapshotEntryContract[];
+    createdAtMs: number;
+    updatedAtMs: number;
+    error?: string;
+}
+export interface MutationCheckpointRestoreContract {
+    restoreId: string;
+    checkpointId: string;
+    runId?: string;
+    sessionId?: string;
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    restoredAtMs: number;
+    reason?: string;
+}
+export interface MutationCheckpointRestoreAckContract {
+    restoreId: string;
+    checkpointId: string;
+    runId?: string;
+    sessionId?: string;
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    requestedAtMs: number;
+    ackedAtMs: number;
+    accepted: boolean;
+    reason?: string;
+}
+export interface MutationCheckpointRollbackResultContract {
+    restoreId: string;
+    checkpointId: string;
+    rollbackCheckpointId: string;
+    runId?: string;
+    sessionId?: string;
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    completedAtMs: number;
+    reason?: string;
+}