@reactive-agents/interaction 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tyler Buell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,46 @@
+# @reactive-agents/interaction
+
+Interaction modes for the [Reactive Agents](https://tylerjrbuell.github.io/reactive-agents-ts/) framework.
+
+Gives agents 5 levels of autonomy — from fully autonomous to human-in-the-loop collaborative — with dynamic transitions based on confidence and cost.
+
+## Installation
+
+```bash
+bun add @reactive-agents/interaction effect
+```
+
+## The 5 Modes
+
+| Mode | Autonomy | When it activates |
+|------|----------|------------------|
+| `autonomous` | Full — no interruptions | High confidence, routine tasks |
+| `supervised` | Periodic checkpoints | Moderate confidence |
+| `collaborative` | Human decides key steps | Complex or ambiguous tasks |
+| `consultative` | Human approves before acting | High-cost or risky operations |
+| `interrogative` | Human provides all direction | Information gathering only |
+
+## Usage
+
+```typescript
+import { ReactiveAgents } from "reactive-agents";
+
+const agent = await ReactiveAgents.create()
+  .withName("assistant")
+  .withProvider("anthropic")
+  .withInteraction({
+    defaultMode: "supervised",
+    onCheckpoint: async (ctx) => {
+      // Called when agent wants human approval
+      console.log("Agent wants to: ", ctx.proposedAction);
+      return { approved: true };
+    },
+  })
+  .build();
+```
+
+Modes transition automatically — an autonomous agent escalates to `consultative` if it detects a high-cost operation, then de-escalates when confidence recovers.
+
+## Documentation
+
+Full documentation at [tylerjrbuell.github.io/reactive-agents-ts/guides/interaction-modes/](https://tylerjrbuell.github.io/reactive-agents-ts/guides/interaction-modes/)

package/dist/index.d.ts

@@ -0,0 +1,423 @@
+import { Schema, Context, Effect, Layer } from 'effect';
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import * as _reactive_agents_core from '@reactive-agents/core';
+import { EventBus } from '@reactive-agents/core';
+
+declare const InteractionModeType: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+type InteractionModeType = typeof InteractionModeType.Type;
+declare const SessionId: Schema.brand<typeof Schema.String, "SessionId">;
+type SessionId = typeof SessionId.Type;
+declare const InteractionModeSchema: Schema.Struct<{
+    mode: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+    agentId: typeof Schema.String;
+    sessionId: Schema.brand<typeof Schema.String, "SessionId">;
+    startedAt: typeof Schema.DateFromSelf;
+    metadata: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.Unknown>>;
+}>;
+type InteractionMode = typeof InteractionModeSchema.Type;
+
+declare const NotificationChannel: Schema.Literal<["in-app", "callback", "event-bus"]>;
+type NotificationChannel = typeof NotificationChannel.Type;
+declare const NotificationPriority: Schema.Literal<["low", "normal", "high", "urgent"]>;
+type NotificationPriority = typeof NotificationPriority.Type;
+declare const NotificationSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    agentId: typeof Schema.String;
+    channel: Schema.Literal<["in-app", "callback", "event-bus"]>;
+    priority: Schema.Literal<["low", "normal", "high", "urgent"]>;
+    title: typeof Schema.String;
+    body: typeof Schema.String;
+    data: Schema.optional<typeof Schema.Unknown>;
+    createdAt: typeof Schema.DateFromSelf;
+    readAt: Schema.optional<typeof Schema.DateFromSelf>;
+}>;
+type Notification = typeof NotificationSchema.Type;
+declare const ReportingFrequency: Schema.Literal<["realtime", "milestone", "hourly", "daily"]>;
+type ReportingFrequency = typeof ReportingFrequency.Type;
+declare const ReportingDetailLevel: Schema.Literal<["minimal", "summary", "detailed"]>;
+type ReportingDetailLevel = typeof ReportingDetailLevel.Type;
+declare const ReportingConfigSchema: Schema.Struct<{
+    frequency: Schema.Literal<["realtime", "milestone", "hourly", "daily"]>;
+    channel: Schema.Literal<["in-app", "callback", "event-bus"]>;
+    detail: Schema.Literal<["minimal", "summary", "detailed"]>;
+    streaming: typeof Schema.Boolean;
+}>;
+type ReportingConfig = typeof ReportingConfigSchema.Type;
+
+declare const EscalationConditionType: Schema.Literal<["uncertainty", "cost", "duration", "user-active", "confidence", "consecutive-approvals"]>;
+type EscalationConditionType = typeof EscalationConditionType.Type;
+declare const EscalationConditionSchema: Schema.Struct<{
+    type: Schema.Literal<["uncertainty", "cost", "duration", "user-active", "confidence", "consecutive-approvals"]>;
+    threshold: typeof Schema.Number;
+}>;
+type EscalationCondition = typeof EscalationConditionSchema.Type;
+declare const ModeTransitionRuleSchema: Schema.Struct<{
+    from: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+    to: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+    conditions: Schema.Array$<Schema.Struct<{
+        type: Schema.Literal<["uncertainty", "cost", "duration", "user-active", "confidence", "consecutive-approvals"]>;
+        threshold: typeof Schema.Number;
+    }>>;
+}>;
+type ModeTransitionRule = typeof ModeTransitionRuleSchema.Type;
+declare const InteractionConfigSchema: Schema.Struct<{
+    defaultMode: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+    interruptRules: Schema.Array$<Schema.Struct<{
+        trigger: Schema.Literal<["error", "uncertainty", "high-cost", "critical-decision", "user-requested", "custom"]>;
+        severity: Schema.Literal<["low", "medium", "high", "critical"]>;
+        threshold: Schema.optional<typeof Schema.Number>;
+        enabled: typeof Schema.Boolean;
+    }>>;
+    reporting: Schema.Struct<{
+        frequency: Schema.Literal<["realtime", "milestone", "hourly", "daily"]>;
+        channel: Schema.Literal<["in-app", "callback", "event-bus"]>;
+        detail: Schema.Literal<["minimal", "summary", "detailed"]>;
+        streaming: typeof Schema.Boolean;
+    }>;
+    checkpoints: Schema.optional<Schema.Struct<{
+        frequency: Schema.Literal<["milestone", "time-based"]>;
+        intervalMs: Schema.optional<typeof Schema.Number>;
+        milestones: Schema.optional<Schema.Array$<typeof Schema.String>>;
+        autoApprove: Schema.Struct<{
+            enabled: typeof Schema.Boolean;
+            timeoutMs: typeof Schema.Number;
+            defaultAction: Schema.Literal<["approve", "reject", "pause"]>;
+        }>;
+    }>>;
+    escalationRules: Schema.Array$<Schema.Struct<{
+        from: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+        to: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+        conditions: Schema.Array$<Schema.Struct<{
+            type: Schema.Literal<["uncertainty", "cost", "duration", "user-active", "confidence", "consecutive-approvals"]>;
+            threshold: typeof Schema.Number;
+        }>>;
+    }>>;
+    deescalationRules: Schema.Array$<Schema.Struct<{
+        from: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+        to: Schema.Literal<["autonomous", "supervised", "collaborative", "consultative", "interrogative"]>;
+        conditions: Schema.Array$<Schema.Struct<{
+            type: Schema.Literal<["uncertainty", "cost", "duration", "user-active", "confidence", "consecutive-approvals"]>;
+            threshold: typeof Schema.Number;
+        }>>;
+    }>>;
+    learningEnabled: typeof Schema.Boolean;
+}>;
+type InteractionConfig = typeof InteractionConfigSchema.Type;
+declare const defaultInteractionConfig: InteractionConfig;
+
+declare const CheckpointStatus: Schema.Literal<["pending", "approved", "rejected", "auto-approved", "expired"]>;
+type CheckpointStatus = typeof CheckpointStatus.Type;
+declare const CheckpointSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    agentId: typeof Schema.String;
+    taskId: typeof Schema.String;
+    milestoneName: typeof Schema.String;
+    description: typeof Schema.String;
+    status: Schema.Literal<["pending", "approved", "rejected", "auto-approved", "expired"]>;
+    createdAt: typeof Schema.DateFromSelf;
+    resolvedAt: Schema.optional<typeof Schema.DateFromSelf>;
+    userComment: Schema.optional<typeof Schema.String>;
+}>;
+type Checkpoint = typeof CheckpointSchema.Type;
+declare const CheckpointFrequency: Schema.Literal<["milestone", "time-based"]>;
+type CheckpointFrequency = typeof CheckpointFrequency.Type;
+declare const AutoApproveAction: Schema.Literal<["approve", "reject", "pause"]>;
+type AutoApproveAction = typeof AutoApproveAction.Type;
+declare const CheckpointConfigSchema: Schema.Struct<{
+    frequency: Schema.Literal<["milestone", "time-based"]>;
+    intervalMs: Schema.optional<typeof Schema.Number>;
+    milestones: Schema.optional<Schema.Array$<typeof Schema.String>>;
+    autoApprove: Schema.Struct<{
+        enabled: typeof Schema.Boolean;
+        timeoutMs: typeof Schema.Number;
+        defaultAction: Schema.Literal<["approve", "reject", "pause"]>;
+    }>;
+}>;
+type CheckpointConfig = typeof CheckpointConfigSchema.Type;
+
+declare const InterruptTrigger: Schema.Literal<["error", "uncertainty", "high-cost", "critical-decision", "user-requested", "custom"]>;
+type InterruptTrigger = typeof InterruptTrigger.Type;
+declare const InterruptSeverity: Schema.Literal<["low", "medium", "high", "critical"]>;
+type InterruptSeverity = typeof InterruptSeverity.Type;
+declare const InterruptRuleSchema: Schema.Struct<{
+    trigger: Schema.Literal<["error", "uncertainty", "high-cost", "critical-decision", "user-requested", "custom"]>;
+    severity: Schema.Literal<["low", "medium", "high", "critical"]>;
+    threshold: Schema.optional<typeof Schema.Number>;
+    enabled: typeof Schema.Boolean;
+}>;
+type InterruptRule = typeof InterruptRuleSchema.Type;
+declare const InterruptEventSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    trigger: Schema.Literal<["error", "uncertainty", "high-cost", "critical-decision", "user-requested", "custom"]>;
+    severity: Schema.Literal<["low", "medium", "high", "critical"]>;
+    agentId: typeof Schema.String;
+    taskId: typeof Schema.String;
+    message: typeof Schema.String;
+    context: Schema.optional<typeof Schema.Unknown>;
+    timestamp: typeof Schema.DateFromSelf;
+    acknowledged: typeof Schema.Boolean;
+}>;
+type InterruptEvent = typeof InterruptEventSchema.Type;
+
+declare const CollaborationStatus: Schema.Literal<["active", "paused", "ended"]>;
+type CollaborationStatus = typeof CollaborationStatus.Type;
+declare const QuestionStyle: Schema.Literal<["inline", "batch", "separate"]>;
+type QuestionStyle = typeof QuestionStyle.Type;
+declare const CollaborationSessionSchema: Schema.Struct<{
+    id: Schema.brand<typeof Schema.String, "SessionId">;
+    agentId: typeof Schema.String;
+    taskId: typeof Schema.String;
+    status: Schema.Literal<["active", "paused", "ended"]>;
+    thinkingVisible: typeof Schema.Boolean;
+    streamingEnabled: typeof Schema.Boolean;
+    questionStyle: Schema.Literal<["inline", "batch", "separate"]>;
+    rollbackEnabled: typeof Schema.Boolean;
+    startedAt: typeof Schema.DateFromSelf;
+    endedAt: Schema.optional<typeof Schema.DateFromSelf>;
+}>;
+type CollaborationSession = typeof CollaborationSessionSchema.Type;
+declare const CollaborationMessageType: Schema.Literal<["thought", "question", "answer", "suggestion", "update", "action"]>;
+type CollaborationMessageType = typeof CollaborationMessageType.Type;
+declare const CollaborationMessageSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    sessionId: Schema.brand<typeof Schema.String, "SessionId">;
+    type: Schema.Literal<["thought", "question", "answer", "suggestion", "update", "action"]>;
+    sender: Schema.Literal<["agent", "user"]>;
+    content: typeof Schema.String;
+    timestamp: typeof Schema.DateFromSelf;
+}>;
+type CollaborationMessage = typeof CollaborationMessageSchema.Type;
+
+declare const ApprovalAction: Schema.Literal<["auto-approve", "auto-reject", "ask"]>;
+type ApprovalAction = typeof ApprovalAction.Type;
+declare const ApprovalPatternSchema: Schema.Struct<{
+    id: typeof Schema.String;
+    taskType: typeof Schema.String;
+    costThreshold: Schema.optional<typeof Schema.Number>;
+    action: Schema.Literal<["auto-approve", "auto-reject", "ask"]>;
+    confidence: typeof Schema.Number;
+    occurrences: typeof Schema.Number;
+    lastSeen: typeof Schema.DateFromSelf;
+}>;
+type ApprovalPattern = typeof ApprovalPatternSchema.Type;
+declare const InterruptionTolerance: Schema.Literal<["low", "medium", "high"]>;
+type InterruptionTolerance = typeof InterruptionTolerance.Type;
+declare const UserPreferenceSchema: Schema.Struct<{
+    userId: typeof Schema.String;
+    learningEnabled: typeof Schema.Boolean;
+    interruptionTolerance: Schema.Literal<["low", "medium", "high"]>;
+    preferredMode: Schema.optional<typeof Schema.String>;
+    approvalPatterns: Schema.Array$<Schema.Struct<{
+        id: typeof Schema.String;
+        taskType: typeof Schema.String;
+        costThreshold: Schema.optional<typeof Schema.Number>;
+        action: Schema.Literal<["auto-approve", "auto-reject", "ask"]>;
+        confidence: typeof Schema.Number;
+        occurrences: typeof Schema.Number;
+        lastSeen: typeof Schema.DateFromSelf;
+    }>>;
+    lastUpdated: typeof Schema.DateFromSelf;
+}>;
+type UserPreference = typeof UserPreferenceSchema.Type;
+
+declare const InteractionError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "InteractionError";
+} & Readonly<A>;
+declare class InteractionError extends InteractionError_base<{
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const ModeError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ModeError";
+} & Readonly<A>;
+declare class ModeError extends ModeError_base<{
+    readonly from: string;
+    readonly to: string;
+    readonly reason: string;
+}> {
+}
+declare const CheckpointError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "CheckpointError";
+} & Readonly<A>;
+declare class CheckpointError extends CheckpointError_base<{
+    readonly checkpointId: string;
+    readonly message: string;
+}> {
+}
+declare const SessionNotFoundError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "SessionNotFoundError";
+} & Readonly<A>;
+declare class SessionNotFoundError extends SessionNotFoundError_base<{
+    readonly sessionId: string;
+}> {
+}
+declare const NotificationError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "NotificationError";
+} & Readonly<A>;
+declare class NotificationError extends NotificationError_base<{
+    readonly channel: string;
+    readonly message: string;
+    readonly cause?: unknown;
+}> {
+}
+declare const InputTimeoutError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "InputTimeoutError";
+} & Readonly<A>;
+declare class InputTimeoutError extends InputTimeoutError_base<{
+    readonly timeoutMs: number;
+    readonly message: string;
+}> {
+}
+type InteractionErrors = InteractionError | ModeError | CheckpointError | SessionNotFoundError | NotificationError | InputTimeoutError;
+
+declare const ModeSwitcher_base: Context.TagClass<ModeSwitcher, "ModeSwitcher", {
+    readonly getMode: (agentId: string) => Effect.Effect<InteractionModeType>;
+    readonly setMode: (agentId: string, targetMode: InteractionModeType) => Effect.Effect<void, ModeError>;
+    readonly evaluateTransition: (agentId: string, context: {
+        confidence?: number;
+        cost?: number;
+        durationMs?: number;
+        userActive?: boolean;
+        consecutiveApprovals?: number;
+    }) => Effect.Effect<InteractionModeType | null>;
+}>;
+declare class ModeSwitcher extends ModeSwitcher_base {
+}
+declare const ModeSwitcherLive: (config?: InteractionConfig) => Layer.Layer<ModeSwitcher, never, EventBus>;
+
+declare const NotificationService_base: Context.TagClass<NotificationService, "NotificationService", {
+    /** Send a notification to user via configured channel. */
+    readonly send: (params: {
+        readonly agentId: string;
+        readonly channel: NotificationChannel;
+        readonly priority: NotificationPriority;
+        readonly title: string;
+        readonly body: string;
+        readonly data?: unknown;
+    }) => Effect.Effect<Notification, NotificationError>;
+    /** List unread notifications. */
+    readonly listUnread: () => Effect.Effect<readonly Notification[]>;
+    /** Mark a notification as read. */
+    readonly markRead: (notificationId: string) => Effect.Effect<void>;
+}>;
+declare class NotificationService extends NotificationService_base {
+}
+declare const NotificationServiceLive: Layer.Layer<NotificationService, never, EventBus>;
+
+declare const CheckpointService_base: Context.TagClass<CheckpointService, "CheckpointService", {
+    readonly createCheckpoint: (params: {
+        agentId: string;
+        taskId: string;
+        milestoneName: string;
+        description: string;
+    }) => Effect.Effect<Checkpoint>;
+    readonly resolveCheckpoint: (checkpointId: string, status: "approved" | "rejected", comment?: string) => Effect.Effect<Checkpoint, CheckpointError>;
+    readonly getCheckpoint: (checkpointId: string) => Effect.Effect<Checkpoint, CheckpointError>;
+    readonly listPending: (agentId?: string) => Effect.Effect<readonly Checkpoint[]>;
+}>;
+declare class CheckpointService extends CheckpointService_base {
+}
+declare const CheckpointServiceLive: Layer.Layer<CheckpointService, never, EventBus>;
+
+declare const CollaborationService_base: Context.TagClass<CollaborationService, "CollaborationService", {
+    readonly startSession: (params: {
+        agentId: string;
+        taskId: string;
+        thinkingVisible?: boolean;
+        streamingEnabled?: boolean;
+    }) => Effect.Effect<CollaborationSession>;
+    readonly endSession: (sessionId: SessionId) => Effect.Effect<void, SessionNotFoundError>;
+    readonly sendMessage: (params: {
+        sessionId: SessionId;
+        type: CollaborationMessage["type"];
+        sender: "agent" | "user";
+        content: string;
+    }) => Effect.Effect<CollaborationMessage, SessionNotFoundError>;
+    readonly getMessages: (sessionId: SessionId) => Effect.Effect<readonly CollaborationMessage[], SessionNotFoundError>;
+    readonly getSession: (sessionId: SessionId) => Effect.Effect<CollaborationSession, SessionNotFoundError>;
+}>;
+declare class CollaborationService extends CollaborationService_base {
+}
+declare const CollaborationServiceLive: Layer.Layer<CollaborationService, never, EventBus>;
+
+declare const PreferenceLearner_base: Context.TagClass<PreferenceLearner, "PreferenceLearner", {
+    readonly getPreference: (userId: string) => Effect.Effect<UserPreference>;
+    readonly recordApproval: (params: {
+        userId: string;
+        taskType: string;
+        approved: boolean;
+        cost?: number;
+    }) => Effect.Effect<void>;
+    readonly shouldAutoApprove: (params: {
+        userId: string;
+        taskType: string;
+        cost?: number;
+    }) => Effect.Effect<boolean>;
+    readonly updateTolerance: (userId: string, tolerance: "low" | "medium" | "high") => Effect.Effect<void>;
+}>;
+declare class PreferenceLearner extends PreferenceLearner_base {
+}
+declare const PreferenceLearnerLive: Layer.Layer<PreferenceLearner, never, never>;
+
+declare const InteractionManager_base: Context.TagClass<InteractionManager, "InteractionManager", {
+    readonly getMode: (agentId: string) => Effect.Effect<InteractionModeType>;
+    readonly switchMode: (agentId: string, mode: InteractionModeType) => Effect.Effect<void, InteractionErrors>;
+    readonly evaluateTransition: (agentId: string, context: {
+        confidence?: number;
+        cost?: number;
+        durationMs?: number;
+        userActive?: boolean;
+        consecutiveApprovals?: number;
+    }) => Effect.Effect<InteractionModeType | null>;
+    readonly notify: (params: {
+        readonly agentId: string;
+        readonly channel: NotificationChannel;
+        readonly priority: NotificationPriority;
+        readonly title: string;
+        readonly body: string;
+    }) => Effect.Effect<Notification, InteractionErrors>;
+    readonly listUnread: () => Effect.Effect<readonly Notification[]>;
+    readonly markRead: (notificationId: string) => Effect.Effect<void>;
+    readonly createCheckpoint: (params: {
+        agentId: string;
+        taskId: string;
+        milestoneName: string;
+        description: string;
+    }) => Effect.Effect<Checkpoint>;
+    readonly resolveCheckpoint: (checkpointId: string, status: "approved" | "rejected", comment?: string) => Effect.Effect<Checkpoint, CheckpointError>;
+    readonly listPendingCheckpoints: (agentId?: string) => Effect.Effect<readonly Checkpoint[]>;
+    readonly startCollaboration: (params: {
+        agentId: string;
+        taskId: string;
+        thinkingVisible?: boolean;
+    }) => Effect.Effect<CollaborationSession>;
+    readonly endCollaboration: (sessionId: SessionId) => Effect.Effect<void, SessionNotFoundError>;
+    readonly sendCollaborationMessage: (params: {
+        sessionId: SessionId;
+        type: CollaborationMessage["type"];
+        sender: "agent" | "user";
+        content: string;
+    }) => Effect.Effect<CollaborationMessage, SessionNotFoundError>;
+    readonly getPreference: (userId: string) => Effect.Effect<UserPreference>;
+    readonly shouldAutoApprove: (params: {
+        userId: string;
+        taskType: string;
+        cost?: number;
+    }) => Effect.Effect<boolean>;
+}>;
+declare class InteractionManager extends InteractionManager_base {
+}
+declare const InteractionManagerLive: Layer.Layer<InteractionManager, never, ModeSwitcher | EventBus | NotificationService | CheckpointService | CollaborationService | PreferenceLearner>;
+
+/**
+ * Create the Interaction layer (Phase 3 — all 5 modes).
+ *
+ * Provides: InteractionManager, ModeSwitcher, NotificationService,
+ *           CheckpointService, CollaborationService, PreferenceLearner
+ * Requires: EventBus (from @reactive-agents/core)
+ */
+declare const createInteractionLayer: (config?: InteractionConfig) => Layer.Layer<ModeSwitcher | NotificationService | CheckpointService | CollaborationService | PreferenceLearner | InteractionManager, never, _reactive_agents_core.EventBus>;
+
+export { ApprovalAction, type ApprovalPattern, ApprovalPatternSchema, AutoApproveAction, type Checkpoint, type CheckpointConfig, CheckpointConfigSchema, CheckpointError, CheckpointFrequency, CheckpointSchema, CheckpointService, CheckpointServiceLive, CheckpointStatus, type CollaborationMessage, CollaborationMessageSchema, CollaborationMessageType, CollaborationService, CollaborationServiceLive, type CollaborationSession, CollaborationSessionSchema, CollaborationStatus, type EscalationCondition, EscalationConditionSchema, EscalationConditionType, InputTimeoutError, type InteractionConfig, InteractionConfigSchema, InteractionError, type InteractionErrors, InteractionManager, InteractionManagerLive, type InteractionMode, InteractionModeSchema, InteractionModeType, type InterruptEvent, InterruptEventSchema, type InterruptRule, InterruptRuleSchema, InterruptSeverity, InterruptTrigger, InterruptionTolerance, ModeError, ModeSwitcher, ModeSwitcherLive, type ModeTransitionRule, ModeTransitionRuleSchema, type Notification, NotificationChannel, NotificationError, NotificationPriority, NotificationSchema, NotificationService, NotificationServiceLive, PreferenceLearner, PreferenceLearnerLive, QuestionStyle, type ReportingConfig, ReportingConfigSchema, ReportingDetailLevel, ReportingFrequency, SessionId, SessionNotFoundError, type UserPreference, UserPreferenceSchema, createInteractionLayer, defaultInteractionConfig };