@arnilo/prism 0.4.0 → 0.5.0

package/dist/agent-session/session.d.ts

@@ -1,7 +1,11 @@
 /** session (0.2.5 plan 025 Task 1 split). Moved verbatim from agent-session.ts; public surface unchanged behind the barrel. */
-import type { StoredAgentRunState } from "../agent-run-state.js";
-import type { Agent, AgentEvent, AgentRunResult, AgentRunStateOptions, AgentSession, AgentSessionConfig, CompactionOptions, CompactionResult, OwnershipScope, RunDecision, RunOptions, SessionEntry, SteerOptions, SubscribeOptions } from "../contracts.js";
+import { ActiveDurableRun } from "../agent-approval.js";
+import type { PendingToolCall, StoredAgentRunState } from "../agent-run-state.js";
+import type { Agent, AgentEvent, AgentRunResult, AgentRunState, AgentRunStateOptions, AgentSession, AgentSessionConfig, AIProvider, CompactionOptions, CompactionResult, ErrorInfo, Message, OwnershipScope, PendingDecision, PromptVersionRef, ProviderRequest, RunDecision, RunOptions, SessionEntry, Skill, SteerOptions, SubscribeOptions, ToolDefinition, ToolEffectStore, Usage } from "../contracts.js";
+import type { AgentIdentity } from "../identity.js";
 import type { AgentInput } from "../input.js";
+import type { RunLimitTracker } from "../run-limits.js";
+import type { SessionContextSnapshot } from "../session-stores.js";
 import type { LoadedSkillBodiesEntry } from "../skill-load.js";
 export declare class RuntimeAgentSession implements AgentSession {
     readonly id: string;
@@ -14,33 +18,36 @@ export declare class RuntimeAgentSession implements AgentSession {
     private activeRun?;
     private activeRunId?;
     private activeProviderTurnAbort?;
-    private pendingSoftInterrupt;
+    pendingSoftInterrupt: boolean;
     private pendingSteers;
     private pendingSteerBytes;
     private activeRedactor?;
-    private activeProvider?;
+    activeProvider?: AIProvider;
     private activeLedger?;
-    private activeEffectStore?;
+    activeEffectStore?: ToolEffectStore;
     private activeOwnership?;
-    private activeIdentity?;
+    activeIdentity?: AgentIdentity;
     private activeIdempotencyKey?;
     private activeGuardrails?;
-    private activeMetadata?;
-    private activePromptVersion?;
-    private activeLimits?;
-    private activeLimitOutputBuffer;
-    private activeDurable?;
-    private activeLoop?;
+    activeMetadata?: Readonly<Record<string, unknown>>;
+    activePromptVersion?: PromptVersionRef;
+    activeLimits?: RunLimitTracker;
+    activeLimitOutputBuffer: boolean;
+    activeDurable?: ActiveDurableRun;
+    activeLoop?: import("../contracts.js").AgentLoopStrategy;
     /** Gated calls of the current tool round awaiting one collected suspension. */
-    private activeGatedRound?;
-    private activeLoopTurn;
+    activeGatedRound?: Map<string, {
+        entry: PendingToolCall;
+        decision: PendingDecision;
+    }>;
+    activeLoopTurn: number;
     private readonly loadedSkills;
     /** Tools activated via `search_tools` this session (plan 041); names-only in persistence. */
-    private readonly activatedTools;
+    readonly activatedTools: import("../tool-search.js").ActiveToolSet;
     /** Plan 018 Task 6 (closeout `checkpoint-bodies`): persisted exact instructions, registry-independent. */
-    private restoredSkillBodies;
+    restoredSkillBodies: readonly LoadedSkillBodiesEntry[];
     /** Skills of the current run (for the bodies snapshot); replaced at each run start. */
-    private activeRunSkills;
+    activeRunSkills: readonly import("../contracts.js").Skill[];
     /** Plan 015 Task 4: re-add persisted loaded-skill names (names only; bodies re-resolve on demand). */
     restoreLoadedSkills(names: readonly string[]): void;
     /** Plan 041: re-add persisted activated-tool names (names only; inert for absent tools). */
@@ -66,15 +73,16 @@ export declare class RuntimeAgentSession implements AgentSession {
     private runInternal;
     prompt(input: string, options?: RunOptions): Promise<AgentRunResult>;
     stream(input: AgentInput, options?: RunOptions & SubscribeOptions): AsyncGenerator<AgentEvent>;
-    private buildRunResult;
-    private suspendDurable;
-    /** First attributed sticky whose scope and delegation path exactly match a nested decision. */
-    private matchNestedSticky;
-    /** First sticky decision whose scope exactly matches this call, if any. */
-    private matchStickyDecision;
-    /** Redacted pending-decision descriptor for one gated call; never carries raw arguments. */
-    private buildPendingDecision;
-    private persistDurable;
+    buildRunResult(input: {
+        readonly runId: string;
+        readonly status: AgentRunResult["status"];
+        readonly usage?: Usage;
+        readonly limit?: import("../contracts.js").RunLimitBreach;
+        readonly error?: ErrorInfo;
+        readonly abortReason?: string;
+        readonly runState?: AgentRunState;
+        readonly interruption?: import("../contracts.js").AgentRunInterruption;
+    }): AgentRunResult;
     compact(options?: CompactionOptions): Promise<CompactionResult>;
     abort(reason?: unknown): void;
     entries(): Promise<readonly SessionEntry[]>;
@@ -87,22 +95,20 @@ export declare class RuntimeAgentSession implements AgentSession {
         readonly leafId?: string;
     }): Promise<AgentSession>;
     private branchReader;
-    private resolveRunProvider;
-    private resolveRunSkills;
-    private emit;
-    private closeSubscribers;
-    private drainLedger;
-    private generateWithRetry;
-    private generateProviderTurn;
-    private applyPendingSteers;
-    private applyProviderRequestPolicies;
-    private appendMessage;
-    private autoCompact;
+    resolveRunProvider(options: RunOptions): void;
+    resolveRunSkills(options: RunOptions, tools: readonly ToolDefinition[]): readonly Skill[];
+    emit(event: AgentEvent): void;
+    closeSubscribers(): void;
+    drainLedger(): Promise<void>;
+    applyPendingSteers(runId: string, metadata: Readonly<Record<string, unknown>>, signal: AbortSignal): Promise<boolean>;
+    applyProviderRequestPolicies(request: ProviderRequest, runId: string, options: RunOptions, metadata: Readonly<Record<string, unknown>>, signal: AbortSignal): Promise<import("../contracts.js").ProviderRequestPolicyResult>;
+    appendMessage(message: Message, runId: string): Promise<void>;
+    autoCompact(runId: string, options: RunOptions, signal: AbortSignal, inputMessages: readonly Message[]): Promise<void>;
     private compactBranch;
-    private appendEntry;
-    private invalidateSnapshot;
-    private redact;
-    private redactProviderRequest;
-    private rebuildHistory;
-    private snapshot;
+    appendEntry(entry: SessionEntry): Promise<void>;
+    invalidateSnapshot(): void;
+    redact<T>(value: T): T;
+    redactProviderRequest(request: ProviderRequest): ProviderRequest;
+    rebuildHistory(): Promise<void>;
+    snapshot(): Promise<SessionContextSnapshot>;
 }