@deepstrike/sdk 0.2.49 → 0.2.51

package/dist/runtime/canonical-kernel-step.d.ts

@@ -0,0 +1,143 @@
+import type { CanonicalKernelInstance, CanonicalRestoreCost } from "../kernel.js";
+import type { Message } from "../types.js";
+import { type InstalledCheckpoint, type KernelJournal } from "./kernel-journal.js";
+import { type KernelObservation, type KernelRunnerAction } from "./kernel-step.js";
+export declare const MAX_CHAIN_POSITION = 1000000000000;
+export type CanonicalKernelInput = Record<string, unknown> & {
+    kind: string;
+};
+export interface CanonicalPlannedStep {
+    root_kind?: "agent" | "workflow";
+    focus?: Record<string, unknown>;
+    observations?: Array<Record<string, unknown>>;
+    disposition: {
+        kind: "effects";
+        effects?: Array<Record<string, unknown>>;
+    } | {
+        kind: "terminal";
+        terminal: Record<string, unknown>;
+    };
+}
+export interface CanonicalTransitionOptions {
+    /** Caller-stable idempotency key. Generated once when omitted. */
+    inputId?: string;
+    /** Decimal-u64 host observation. Captured once when omitted and preserved across every retry. */
+    observedAtMs?: string;
+}
+export interface CanonicalTransition {
+    inputJson: string;
+    stepSeq: number;
+    recordDigest: string;
+    plannedStep: CanonicalPlannedStep;
+    checkpointAdvice?: Record<string, unknown>;
+    replayed: boolean;
+}
+export declare function canonicalUnsupportedEffectResolution(effectId: string, effectKind: string): CanonicalKernelInput;
+/** The only ABI-v3 planned-step → Node host-action projection. */
+export declare function canonicalActionFromPlannedStep(plannedStep: CanonicalPlannedStep): KernelRunnerAction | null;
+export declare class CanonicalKernelRejectedError extends Error {
+    readonly fault: Record<string, unknown>;
+    constructor(faultJson: string);
+}
+/**
+ * A record is already authoritative once the journal append returns. A later native commit failure
+ * is therefore a rebuild boundary, never an abort boundary.
+ */
+export declare class CanonicalKernelRebuildRequiredError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Node's canonical durable staged-transition host.
+ *
+ * It owns no scheduler truth. Core prepares opaque record bytes; `KernelJournal` makes those bytes
+ * authoritative; only then may core commit and expose the planned effects/terminal to the runner.
+ */
+export declare class CanonicalKernelHost {
+    readonly kernel: CanonicalKernelInstance;
+    readonly journal: KernelJournal;
+    readonly operationId: string;
+    constructor(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string);
+    transition(input: CanonicalKernelInput, options?: CanonicalTransitionOptions): Promise<CanonicalTransition>;
+    /** Restore the latest installed checkpoint and its authoritative record tail in place. */
+    restore(): Promise<CanonicalRestoreCost>;
+    /**
+     * Replay a crash-window outbound envelope with identical bytes (adjudication 5e.3).
+     * No-op when nothing is staged. Clears the stage after commit/replay/reject.
+     */
+    drainOutboundEnvelope(): Promise<CanonicalTransition | undefined>;
+    /** Execute the full §12.3 install/ack/reclaim boundary. */
+    checkpoint(): Promise<InstalledCheckpoint>;
+    private transitionEnvelope;
+}
+export interface CanonicalRunnerRuntimeOptions {
+    maxContextTokens: number;
+    maxTurns?: number;
+    maxTotalTokens?: number;
+    maxWallMs?: number;
+    memoryBindingId?: string;
+    persistPayload?: (callId: string, content: string, previewBytes: number) => Promise<{
+        payloadRef: string;
+        digest: string;
+        originalSize: string;
+        preview: string;
+    }>;
+}
+/**
+ * Canonical operation runtime used by the Node host.
+ * Every durable transition below is one of the canonical ABI's five input classes; no legacy
+ * envelope or synthesized host transaction reaches core or storage.
+ */
+export declare class CanonicalRunnerRuntime {
+    private readonly options;
+    private readonly host;
+    private readonly config;
+    private readonly initialContext;
+    private configured;
+    private started;
+    private turns;
+    private lastAction;
+    private readonly newMessages;
+    private readonly hostObservations;
+    private spawnedTasks;
+    private readonly memoryBindingId;
+    private payloadInlineThreshold;
+    private payloadPreviewBytes;
+    constructor(kernel: CanonicalKernelInstance, journal: KernelJournal, operationId: string, options: CanonicalRunnerRuntimeOptions);
+    get operationId(): string;
+    get journal(): KernelJournal;
+    turn(): number;
+    isTerminal(): boolean;
+    recoveryContentBytes(): number;
+    preservedRefs(): string[];
+    drainNewMessages(): Message[];
+    drainHostObservations(): KernelObservationLike[];
+    terminal(): Record<string, unknown> | undefined;
+    localSubagentsSpawned(): number;
+    restore(): Promise<void>;
+    resumeAction(): KernelRunnerAction | null;
+    startAgent(taskValue: Record<string, unknown>, runSpecValue?: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    startWorkflow(specValue: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    applyHostEvent(event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+    private ensureConfigured;
+    private commit;
+    private currentAction;
+    private pendingEffects;
+    private succeededEffect;
+    private failedEffect;
+    private pageOutResolution;
+    private canonicalSignal;
+    private canonicalCapabilityCommand;
+    private applyBootstrapEvent;
+    private featurePolicy;
+    private executionPolicy;
+    private mergeHostConfig;
+}
+export declare function canonicalKernelApply(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelObservationLike[]>;
+export declare function canonicalKernelMaybeAction(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+export declare function canonicalKernelAction(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], event: Record<string, unknown>): Promise<KernelRunnerAction>;
+export declare function canonicalStartAgent(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], task: Record<string, unknown>, runSpec?: Record<string, unknown>): Promise<KernelRunnerAction>;
+export declare function canonicalStartWorkflow(runtime: CanonicalRunnerRuntime, pending: KernelObservationLike[], spec: Record<string, unknown>): Promise<KernelRunnerAction | null>;
+type KernelObservationLike = KernelObservation;
+export {};