@reactive-agents/interaction 0.1.0

package/dist/index.js

@@ -0,0 +1,782 @@
+// src/types/mode.ts
+import { Schema } from "effect";
+var InteractionModeType = Schema.Literal(
+  "autonomous",
+  // Fire-and-forget: agent runs independently
+  "supervised",
+  // Checkpoints: agent pauses at milestones for approval
+  "collaborative",
+  // Real-time: agent and user work together
+  "consultative",
+  // Advisory: agent observes and suggests
+  "interrogative"
+  // Drill-down: user explores agent state/reasoning
+);
+var SessionId = Schema.String.pipe(Schema.brand("SessionId"));
+var InteractionModeSchema = Schema.Struct({
+  mode: InteractionModeType,
+  agentId: Schema.String,
+  sessionId: SessionId,
+  startedAt: Schema.DateFromSelf,
+  metadata: Schema.optional(
+    Schema.Record({ key: Schema.String, value: Schema.Unknown })
+  )
+});
+
+// src/types/checkpoint.ts
+import { Schema as Schema2 } from "effect";
+var CheckpointStatus = Schema2.Literal(
+  "pending",
+  "approved",
+  "rejected",
+  "auto-approved",
+  "expired"
+);
+var CheckpointSchema = Schema2.Struct({
+  id: Schema2.String,
+  agentId: Schema2.String,
+  taskId: Schema2.String,
+  milestoneName: Schema2.String,
+  description: Schema2.String,
+  status: CheckpointStatus,
+  createdAt: Schema2.DateFromSelf,
+  resolvedAt: Schema2.optional(Schema2.DateFromSelf),
+  userComment: Schema2.optional(Schema2.String)
+});
+var CheckpointFrequency = Schema2.Literal("milestone", "time-based");
+var AutoApproveAction = Schema2.Literal("approve", "reject", "pause");
+var CheckpointConfigSchema = Schema2.Struct({
+  frequency: CheckpointFrequency,
+  intervalMs: Schema2.optional(Schema2.Number),
+  milestones: Schema2.optional(Schema2.Array(Schema2.String)),
+  autoApprove: Schema2.Struct({
+    enabled: Schema2.Boolean,
+    timeoutMs: Schema2.Number,
+    defaultAction: AutoApproveAction
+  })
+});
+
+// src/types/notification.ts
+import { Schema as Schema3 } from "effect";
+var NotificationChannel = Schema3.Literal(
+  "in-app",
+  // Dashboard notification
+  "callback",
+  // Programmatic callback
+  "event-bus"
+  // EventBus from Layer 1
+);
+var NotificationPriority = Schema3.Literal(
+  "low",
+  "normal",
+  "high",
+  "urgent"
+);
+var NotificationSchema = Schema3.Struct({
+  id: Schema3.String,
+  agentId: Schema3.String,
+  channel: NotificationChannel,
+  priority: NotificationPriority,
+  title: Schema3.String,
+  body: Schema3.String,
+  data: Schema3.optional(Schema3.Unknown),
+  createdAt: Schema3.DateFromSelf,
+  readAt: Schema3.optional(Schema3.DateFromSelf)
+});
+var ReportingFrequency = Schema3.Literal(
+  "realtime",
+  "milestone",
+  "hourly",
+  "daily"
+);
+var ReportingDetailLevel = Schema3.Literal(
+  "minimal",
+  "summary",
+  "detailed"
+);
+var ReportingConfigSchema = Schema3.Struct({
+  frequency: ReportingFrequency,
+  channel: NotificationChannel,
+  detail: ReportingDetailLevel,
+  streaming: Schema3.Boolean
+});
+
+// src/types/interrupt.ts
+import { Schema as Schema4 } from "effect";
+var InterruptTrigger = Schema4.Literal(
+  "error",
+  "uncertainty",
+  "high-cost",
+  "critical-decision",
+  "user-requested",
+  "custom"
+);
+var InterruptSeverity = Schema4.Literal("low", "medium", "high", "critical");
+var InterruptRuleSchema = Schema4.Struct({
+  trigger: InterruptTrigger,
+  severity: InterruptSeverity,
+  threshold: Schema4.optional(Schema4.Number),
+  enabled: Schema4.Boolean
+});
+var InterruptEventSchema = Schema4.Struct({
+  id: Schema4.String,
+  trigger: InterruptTrigger,
+  severity: InterruptSeverity,
+  agentId: Schema4.String,
+  taskId: Schema4.String,
+  message: Schema4.String,
+  context: Schema4.optional(Schema4.Unknown),
+  timestamp: Schema4.DateFromSelf,
+  acknowledged: Schema4.Boolean
+});
+
+// src/types/collaboration.ts
+import { Schema as Schema5 } from "effect";
+var CollaborationStatus = Schema5.Literal("active", "paused", "ended");
+var QuestionStyle = Schema5.Literal("inline", "batch", "separate");
+var CollaborationSessionSchema = Schema5.Struct({
+  id: SessionId,
+  agentId: Schema5.String,
+  taskId: Schema5.String,
+  status: CollaborationStatus,
+  thinkingVisible: Schema5.Boolean,
+  streamingEnabled: Schema5.Boolean,
+  questionStyle: QuestionStyle,
+  rollbackEnabled: Schema5.Boolean,
+  startedAt: Schema5.DateFromSelf,
+  endedAt: Schema5.optional(Schema5.DateFromSelf)
+});
+var CollaborationMessageType = Schema5.Literal(
+  "thought",
+  "question",
+  "answer",
+  "suggestion",
+  "update",
+  "action"
+);
+var CollaborationMessageSchema = Schema5.Struct({
+  id: Schema5.String,
+  sessionId: SessionId,
+  type: CollaborationMessageType,
+  sender: Schema5.Literal("agent", "user"),
+  content: Schema5.String,
+  timestamp: Schema5.DateFromSelf
+});
+
+// src/types/preference.ts
+import { Schema as Schema6 } from "effect";
+var ApprovalAction = Schema6.Literal("auto-approve", "auto-reject", "ask");
+var ApprovalPatternSchema = Schema6.Struct({
+  id: Schema6.String,
+  taskType: Schema6.String,
+  costThreshold: Schema6.optional(Schema6.Number),
+  action: ApprovalAction,
+  confidence: Schema6.Number,
+  occurrences: Schema6.Number,
+  lastSeen: Schema6.DateFromSelf
+});
+var InterruptionTolerance = Schema6.Literal("low", "medium", "high");
+var UserPreferenceSchema = Schema6.Struct({
+  userId: Schema6.String,
+  learningEnabled: Schema6.Boolean,
+  interruptionTolerance: InterruptionTolerance,
+  preferredMode: Schema6.optional(Schema6.String),
+  approvalPatterns: Schema6.Array(ApprovalPatternSchema),
+  lastUpdated: Schema6.DateFromSelf
+});
+
+// src/types/config.ts
+import { Schema as Schema7 } from "effect";
+var EscalationConditionType = Schema7.Literal(
+  "uncertainty",
+  "cost",
+  "duration",
+  "user-active",
+  "confidence",
+  "consecutive-approvals"
+);
+var EscalationConditionSchema = Schema7.Struct({
+  type: EscalationConditionType,
+  threshold: Schema7.Number
+});
+var ModeTransitionRuleSchema = Schema7.Struct({
+  from: InteractionModeType,
+  to: InteractionModeType,
+  conditions: Schema7.Array(EscalationConditionSchema)
+});
+var InteractionConfigSchema = Schema7.Struct({
+  defaultMode: InteractionModeType,
+  interruptRules: Schema7.Array(InterruptRuleSchema),
+  reporting: ReportingConfigSchema,
+  checkpoints: Schema7.optional(CheckpointConfigSchema),
+  escalationRules: Schema7.Array(ModeTransitionRuleSchema),
+  deescalationRules: Schema7.Array(ModeTransitionRuleSchema),
+  learningEnabled: Schema7.Boolean
+});
+var defaultInteractionConfig = {
+  defaultMode: "autonomous",
+  interruptRules: [
+    { trigger: "error", severity: "high", enabled: true },
+    { trigger: "uncertainty", severity: "medium", threshold: 0.3, enabled: true },
+    { trigger: "high-cost", severity: "medium", threshold: 10, enabled: true },
+    { trigger: "critical-decision", severity: "critical", enabled: true }
+  ],
+  reporting: {
+    frequency: "milestone",
+    channel: "event-bus",
+    detail: "summary",
+    streaming: false
+  },
+  escalationRules: [
+    {
+      from: "autonomous",
+      to: "supervised",
+      conditions: [{ type: "uncertainty", threshold: 0.3 }]
+    },
+    {
+      from: "supervised",
+      to: "collaborative",
+      conditions: [
+        { type: "uncertainty", threshold: 0.5 },
+        { type: "user-active", threshold: 1 }
+      ]
+    }
+  ],
+  deescalationRules: [
+    {
+      from: "collaborative",
+      to: "autonomous",
+      conditions: [
+        { type: "confidence", threshold: 0.9 },
+        { type: "consecutive-approvals", threshold: 3 }
+      ]
+    }
+  ],
+  learningEnabled: true
+};
+
+// src/errors/errors.ts
+import { Data } from "effect";
+var InteractionError = class extends Data.TaggedError("InteractionError") {
+};
+var ModeError = class extends Data.TaggedError("ModeError") {
+};
+var CheckpointError = class extends Data.TaggedError("CheckpointError") {
+};
+var SessionNotFoundError = class extends Data.TaggedError("SessionNotFoundError") {
+};
+var NotificationError = class extends Data.TaggedError("NotificationError") {
+};
+var InputTimeoutError = class extends Data.TaggedError("InputTimeoutError") {
+};
+
+// src/services/interaction-manager.ts
+import { Context as Context6, Effect as Effect6, Layer as Layer6 } from "effect";
+
+// src/services/mode-switcher.ts
+import { Context, Effect, Layer, Ref } from "effect";
+import { EventBus } from "@reactive-agents/core";
+var ModeSwitcher = class extends Context.Tag("ModeSwitcher")() {
+};
+var ModeSwitcherLive = (config = defaultInteractionConfig) => Layer.effect(
+  ModeSwitcher,
+  Effect.gen(function* () {
+    const eventBus = yield* EventBus;
+    const modesRef = yield* Ref.make(/* @__PURE__ */ new Map());
+    const checkConditions = (rule, context) => {
+      return rule.conditions.every((condition) => {
+        switch (condition.type) {
+          case "uncertainty":
+            return context.confidence !== void 0 && context.confidence < condition.threshold;
+          case "cost":
+            return context.cost !== void 0 && context.cost > condition.threshold;
+          case "duration":
+            return context.durationMs !== void 0 && context.durationMs > condition.threshold;
+          case "user-active":
+            return context.userActive === true;
+          case "confidence":
+            return context.confidence !== void 0 && context.confidence >= condition.threshold;
+          case "consecutive-approvals":
+            return context.consecutiveApprovals !== void 0 && context.consecutiveApprovals >= condition.threshold;
+          default:
+            return false;
+        }
+      });
+    };
+    return {
+      getMode: (agentId) => Ref.get(modesRef).pipe(
+        Effect.map((m) => m.get(agentId) ?? config.defaultMode)
+      ),
+      setMode: (agentId, targetMode) => Effect.gen(function* () {
+        const currentMode = yield* Ref.get(modesRef).pipe(
+          Effect.map((m) => m.get(agentId) ?? config.defaultMode)
+        );
+        if (currentMode === targetMode) return;
+        yield* Ref.update(modesRef, (m) => {
+          const next = new Map(m);
+          next.set(agentId, targetMode);
+          return next;
+        });
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.mode-changed",
+          payload: { agentId, from: currentMode, to: targetMode }
+        });
+      }),
+      evaluateTransition: (agentId, context) => Effect.gen(function* () {
+        const currentMode = yield* Ref.get(modesRef).pipe(
+          Effect.map((m) => m.get(agentId) ?? config.defaultMode)
+        );
+        for (const rule of config.escalationRules) {
+          if (rule.from === currentMode && checkConditions(rule, context)) {
+            return rule.to;
+          }
+        }
+        for (const rule of config.deescalationRules) {
+          if (rule.from === currentMode && checkConditions(rule, context)) {
+            return rule.to;
+          }
+        }
+        return null;
+      })
+    };
+  })
+);
+
+// src/services/notification-service.ts
+import { Context as Context2, Effect as Effect2, Layer as Layer2, Ref as Ref2 } from "effect";
+import { ulid } from "ulid";
+import { EventBus as EventBus2 } from "@reactive-agents/core";
+var NotificationService = class extends Context2.Tag("NotificationService")() {
+};
+var NotificationServiceLive = Layer2.effect(
+  NotificationService,
+  Effect2.gen(function* () {
+    const eventBus = yield* EventBus2;
+    const notificationsRef = yield* Ref2.make(
+      /* @__PURE__ */ new Map()
+    );
+    return {
+      send: (params) => Effect2.gen(function* () {
+        const notification = {
+          id: ulid(),
+          agentId: params.agentId,
+          channel: params.channel,
+          priority: params.priority,
+          title: params.title,
+          body: params.body,
+          data: params.data,
+          createdAt: /* @__PURE__ */ new Date(),
+          readAt: void 0
+        };
+        yield* Ref2.update(notificationsRef, (m) => {
+          const next = new Map(m);
+          next.set(notification.id, notification);
+          return next;
+        });
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.notification",
+          payload: notification
+        });
+        return notification;
+      }),
+      listUnread: () => Ref2.get(notificationsRef).pipe(
+        Effect2.map(
+          (m) => Array.from(m.values()).filter((n) => n.readAt == null)
+        )
+      ),
+      markRead: (notificationId) => Ref2.update(notificationsRef, (m) => {
+        const next = new Map(m);
+        const n = next.get(notificationId);
+        if (n) {
+          next.set(notificationId, { ...n, readAt: /* @__PURE__ */ new Date() });
+        }
+        return next;
+      })
+    };
+  })
+);
+
+// src/services/checkpoint-service.ts
+import { Context as Context3, Effect as Effect3, Layer as Layer3, Ref as Ref3 } from "effect";
+import { EventBus as EventBus3 } from "@reactive-agents/core";
+var CheckpointService = class extends Context3.Tag("CheckpointService")() {
+};
+var CheckpointServiceLive = Layer3.effect(
+  CheckpointService,
+  Effect3.gen(function* () {
+    const eventBus = yield* EventBus3;
+    const checkpointsRef = yield* Ref3.make(/* @__PURE__ */ new Map());
+    return {
+      createCheckpoint: (params) => Effect3.gen(function* () {
+        const checkpoint = {
+          id: crypto.randomUUID(),
+          agentId: params.agentId,
+          taskId: params.taskId,
+          milestoneName: params.milestoneName,
+          description: params.description,
+          status: "pending",
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        yield* Ref3.update(checkpointsRef, (m) => {
+          const next = new Map(m);
+          next.set(checkpoint.id, checkpoint);
+          return next;
+        });
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.checkpoint-created",
+          payload: checkpoint
+        });
+        return checkpoint;
+      }),
+      resolveCheckpoint: (checkpointId, status, comment) => Effect3.gen(function* () {
+        const checkpoints = yield* Ref3.get(checkpointsRef);
+        const existing = checkpoints.get(checkpointId);
+        if (!existing) {
+          return yield* Effect3.fail(
+            new CheckpointError({ checkpointId, message: "Checkpoint not found" })
+          );
+        }
+        const resolved = {
+          ...existing,
+          status,
+          resolvedAt: /* @__PURE__ */ new Date(),
+          userComment: comment
+        };
+        yield* Ref3.update(checkpointsRef, (m) => {
+          const next = new Map(m);
+          next.set(checkpointId, resolved);
+          return next;
+        });
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.checkpoint-resolved",
+          payload: resolved
+        });
+        return resolved;
+      }),
+      getCheckpoint: (checkpointId) => Effect3.gen(function* () {
+        const checkpoints = yield* Ref3.get(checkpointsRef);
+        const cp = checkpoints.get(checkpointId);
+        if (!cp) {
+          return yield* Effect3.fail(
+            new CheckpointError({ checkpointId, message: "Checkpoint not found" })
+          );
+        }
+        return cp;
+      }),
+      listPending: (agentId) => Ref3.get(checkpointsRef).pipe(
+        Effect3.map(
+          (m) => Array.from(m.values()).filter(
+            (cp) => cp.status === "pending" && (!agentId || cp.agentId === agentId)
+          )
+        )
+      )
+    };
+  })
+);
+
+// src/services/collaboration-service.ts
+import { Context as Context4, Effect as Effect4, Layer as Layer4, Ref as Ref4 } from "effect";
+import { EventBus as EventBus4 } from "@reactive-agents/core";
+var CollaborationService = class extends Context4.Tag("CollaborationService")() {
+};
+var CollaborationServiceLive = Layer4.effect(
+  CollaborationService,
+  Effect4.gen(function* () {
+    const eventBus = yield* EventBus4;
+    const sessionsRef = yield* Ref4.make(/* @__PURE__ */ new Map());
+    const messagesRef = yield* Ref4.make(/* @__PURE__ */ new Map());
+    return {
+      startSession: (params) => Effect4.gen(function* () {
+        const sessionId = crypto.randomUUID();
+        const session = {
+          id: sessionId,
+          agentId: params.agentId,
+          taskId: params.taskId,
+          status: "active",
+          thinkingVisible: params.thinkingVisible ?? true,
+          streamingEnabled: params.streamingEnabled ?? false,
+          questionStyle: "inline",
+          rollbackEnabled: false,
+          startedAt: /* @__PURE__ */ new Date()
+        };
+        yield* Ref4.update(sessionsRef, (m) => {
+          const next = new Map(m);
+          next.set(sessionId, session);
+          return next;
+        });
+        yield* Ref4.update(messagesRef, (m) => {
+          const next = new Map(m);
+          next.set(sessionId, []);
+          return next;
+        });
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.collaboration-started",
+          payload: session
+        });
+        return session;
+      }),
+      endSession: (sessionId) => Effect4.gen(function* () {
+        const sessions = yield* Ref4.get(sessionsRef);
+        const session = sessions.get(sessionId);
+        if (!session) {
+          return yield* Effect4.fail(new SessionNotFoundError({ sessionId }));
+        }
+        yield* Ref4.update(sessionsRef, (m) => {
+          const next = new Map(m);
+          next.set(sessionId, { ...session, status: "ended", endedAt: /* @__PURE__ */ new Date() });
+          return next;
+        });
+      }),
+      sendMessage: (params) => Effect4.gen(function* () {
+        const sessions = yield* Ref4.get(sessionsRef);
+        if (!sessions.has(params.sessionId)) {
+          return yield* Effect4.fail(new SessionNotFoundError({ sessionId: params.sessionId }));
+        }
+        const message = {
+          id: crypto.randomUUID(),
+          sessionId: params.sessionId,
+          type: params.type,
+          sender: params.sender,
+          content: params.content,
+          timestamp: /* @__PURE__ */ new Date()
+        };
+        yield* Ref4.update(messagesRef, (m) => {
+          const next = new Map(m);
+          const existing = next.get(params.sessionId) ?? [];
+          next.set(params.sessionId, [...existing, message]);
+          return next;
+        });
+        return message;
+      }),
+      getMessages: (sessionId) => Effect4.gen(function* () {
+        const sessions = yield* Ref4.get(sessionsRef);
+        if (!sessions.has(sessionId)) {
+          return yield* Effect4.fail(new SessionNotFoundError({ sessionId }));
+        }
+        const msgs = yield* Ref4.get(messagesRef);
+        return msgs.get(sessionId) ?? [];
+      }),
+      getSession: (sessionId) => Effect4.gen(function* () {
+        const sessions = yield* Ref4.get(sessionsRef);
+        const session = sessions.get(sessionId);
+        if (!session) {
+          return yield* Effect4.fail(new SessionNotFoundError({ sessionId }));
+        }
+        return session;
+      })
+    };
+  })
+);
+
+// src/services/preference-learner.ts
+import { Context as Context5, Effect as Effect5, Layer as Layer5, Ref as Ref5 } from "effect";
+var PreferenceLearner = class extends Context5.Tag("PreferenceLearner")() {
+};
+var PreferenceLearnerLive = Layer5.effect(
+  PreferenceLearner,
+  Effect5.gen(function* () {
+    const prefsRef = yield* Ref5.make(/* @__PURE__ */ new Map());
+    const getOrCreatePref = (userId) => Ref5.get(prefsRef).pipe(
+      Effect5.map(
+        (m) => m.get(userId) ?? {
+          userId,
+          learningEnabled: true,
+          interruptionTolerance: "medium",
+          approvalPatterns: [],
+          lastUpdated: /* @__PURE__ */ new Date()
+        }
+      )
+    );
+    return {
+      getPreference: (userId) => getOrCreatePref(userId),
+      recordApproval: (params) => Effect5.gen(function* () {
+        const pref = yield* getOrCreatePref(params.userId);
+        const existing = pref.approvalPatterns.find(
+          (p) => p.taskType === params.taskType
+        );
+        let updatedPatterns;
+        if (existing) {
+          updatedPatterns = pref.approvalPatterns.map(
+            (p) => p.taskType === params.taskType ? {
+              ...p,
+              occurrences: p.occurrences + 1,
+              confidence: Math.min(1, p.confidence + 0.1),
+              action: params.approved ? "auto-approve" : p.action,
+              lastSeen: /* @__PURE__ */ new Date()
+            } : p
+          );
+        } else {
+          updatedPatterns = [
+            ...pref.approvalPatterns,
+            {
+              id: crypto.randomUUID(),
+              taskType: params.taskType,
+              costThreshold: params.cost,
+              action: params.approved ? "auto-approve" : "ask",
+              confidence: 0.3,
+              occurrences: 1,
+              lastSeen: /* @__PURE__ */ new Date()
+            }
+          ];
+        }
+        yield* Ref5.update(prefsRef, (m) => {
+          const next = new Map(m);
+          next.set(params.userId, {
+            ...pref,
+            approvalPatterns: updatedPatterns,
+            lastUpdated: /* @__PURE__ */ new Date()
+          });
+          return next;
+        });
+      }),
+      shouldAutoApprove: (params) => Effect5.gen(function* () {
+        const pref = yield* getOrCreatePref(params.userId);
+        if (!pref.learningEnabled) return false;
+        const pattern = pref.approvalPatterns.find(
+          (p) => p.taskType === params.taskType
+        );
+        if (!pattern) return false;
+        if (pattern.confidence < 0.7 || pattern.occurrences < 3) return false;
+        if (pattern.action !== "auto-approve") return false;
+        if (params.cost && pattern.costThreshold && params.cost > pattern.costThreshold) {
+          return false;
+        }
+        return true;
+      }),
+      updateTolerance: (userId, tolerance) => Effect5.gen(function* () {
+        const pref = yield* getOrCreatePref(userId);
+        yield* Ref5.update(prefsRef, (m) => {
+          const next = new Map(m);
+          next.set(userId, {
+            ...pref,
+            interruptionTolerance: tolerance,
+            lastUpdated: /* @__PURE__ */ new Date()
+          });
+          return next;
+        });
+      })
+    };
+  })
+);
+
+// src/services/interaction-manager.ts
+import { EventBus as EventBus5 } from "@reactive-agents/core";
+var InteractionManager = class extends Context6.Tag("InteractionManager")() {
+};
+var InteractionManagerLive = Layer6.effect(
+  InteractionManager,
+  Effect6.gen(function* () {
+    const modeSwitcher = yield* ModeSwitcher;
+    const notifications = yield* NotificationService;
+    const checkpoints = yield* CheckpointService;
+    const collaboration = yield* CollaborationService;
+    const preferences = yield* PreferenceLearner;
+    const eventBus = yield* EventBus5;
+    return {
+      // Mode
+      getMode: (agentId) => modeSwitcher.getMode(agentId),
+      switchMode: (agentId, mode) => Effect6.gen(function* () {
+        yield* modeSwitcher.setMode(agentId, mode);
+        yield* eventBus.publish({
+          _tag: "Custom",
+          type: "interaction.mode-changed",
+          payload: { agentId, mode }
+        });
+      }),
+      evaluateTransition: (agentId, context) => modeSwitcher.evaluateTransition(agentId, context),
+      // Notifications
+      notify: (params) => notifications.send({ ...params, data: void 0 }),
+      listUnread: () => notifications.listUnread(),
+      markRead: (notificationId) => notifications.markRead(notificationId),
+      // Checkpoints
+      createCheckpoint: (params) => checkpoints.createCheckpoint(params),
+      resolveCheckpoint: (id, status, comment) => checkpoints.resolveCheckpoint(id, status, comment),
+      listPendingCheckpoints: (agentId) => checkpoints.listPending(agentId),
+      // Collaboration
+      startCollaboration: (params) => collaboration.startSession(params),
+      endCollaboration: (sessionId) => collaboration.endSession(sessionId),
+      sendCollaborationMessage: (params) => collaboration.sendMessage(params),
+      // Preferences
+      getPreference: (userId) => preferences.getPreference(userId),
+      shouldAutoApprove: (params) => preferences.shouldAutoApprove(params)
+    };
+  })
+);
+
+// src/runtime.ts
+import { Layer as Layer7 } from "effect";
+var createInteractionLayer = (config = defaultInteractionConfig) => {
+  const NotificationLayer = NotificationServiceLive;
+  const SwitcherLayer = ModeSwitcherLive(config);
+  const CheckpointLayer = CheckpointServiceLive;
+  const CollaborationLayer = CollaborationServiceLive;
+  const PreferenceLayer = PreferenceLearnerLive;
+  const LeafLayers = Layer7.mergeAll(
+    NotificationLayer,
+    SwitcherLayer,
+    CheckpointLayer,
+    CollaborationLayer,
+    PreferenceLayer
+  );
+  const ManagerLayer = InteractionManagerLive.pipe(Layer7.provide(LeafLayers));
+  return Layer7.mergeAll(ManagerLayer, LeafLayers);
+};
+export {
+  ApprovalAction,
+  ApprovalPatternSchema,
+  AutoApproveAction,
+  CheckpointConfigSchema,
+  CheckpointError,
+  CheckpointFrequency,
+  CheckpointSchema,
+  CheckpointService,
+  CheckpointServiceLive,
+  CheckpointStatus,
+  CollaborationMessageSchema,
+  CollaborationMessageType,
+  CollaborationService,
+  CollaborationServiceLive,
+  CollaborationSessionSchema,
+  CollaborationStatus,
+  EscalationConditionSchema,
+  EscalationConditionType,
+  InputTimeoutError,
+  InteractionConfigSchema,
+  InteractionError,
+  InteractionManager,
+  InteractionManagerLive,
+  InteractionModeSchema,
+  InteractionModeType,
+  InterruptEventSchema,
+  InterruptRuleSchema,
+  InterruptSeverity,
+  InterruptTrigger,
+  InterruptionTolerance,
+  ModeError,
+  ModeSwitcher,
+  ModeSwitcherLive,
+  ModeTransitionRuleSchema,
+  NotificationChannel,
+  NotificationError,
+  NotificationPriority,
+  NotificationSchema,
+  NotificationService,
+  NotificationServiceLive,
+  PreferenceLearner,
+  PreferenceLearnerLive,
+  QuestionStyle,
+  ReportingConfigSchema,
+  ReportingDetailLevel,
+  ReportingFrequency,
+  SessionId,
+  SessionNotFoundError,
+  UserPreferenceSchema,
+  createInteractionLayer,
+  defaultInteractionConfig
+};
+//# sourceMappingURL=index.js.map