registerConversation method

void registerConversation(ConversationLifecycle lifecycle)

Register conversation lifecycle callbacks.

Implementation

void registerConversation(ConversationLifecycle lifecycle) {
  if (lifecycle.onConversationStart != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:conversation:start',
        type: HookType.onConversationStart,
        priority: HookPriority.normal,
        name: 'Conversation Start Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = ConversationStartedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            conversationId:
                context.metadata['conversationId'] as String? ?? '',
            isContinuation:
                context.metadata['isContinuation'] as bool? ?? false,
          );
          await lifecycle.onConversationStart!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onTurnStart != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:turn:start',
        type: HookType.preMessage,
        priority: HookPriority.normal,
        name: 'Turn Start Lifecycle',
        source: 'lifecycle',
        matcher: (context) =>
            context is MessageHookContext && context.role == 'user',
        asyncHandler: (context) async {
          final event = TurnStartedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            turnIndex: context.turnIndex ?? 0,
            userMessage: context is MessageHookContext ? context.content : '',
          );
          await lifecycle.onTurnStart!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onTurnEnd != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:turn:end',
        type: HookType.postMessage,
        priority: HookPriority.normal,
        name: 'Turn End Lifecycle',
        source: 'lifecycle',
        matcher: (context) =>
            context is MessageHookContext && context.role == 'assistant',
        asyncHandler: (context) async {
          final event = TurnEndedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            turnIndex: context.turnIndex ?? 0,
            tokensUsed: context.metadata['tokensUsed'] as int? ?? 0,
            toolInvocations: context.metadata['toolInvocations'] as int? ?? 0,
            duration:
                context.metadata['turnDuration'] as Duration? ??
                Duration.zero,
          );
          await lifecycle.onTurnEnd!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onConversationEnd != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:conversation:end',
        type: HookType.onConversationEnd,
        priority: HookPriority.normal,
        name: 'Conversation End Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = ConversationEndedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            conversationId:
                context.metadata['conversationId'] as String? ?? '',
            turnCount: context.metadata['turnCount'] as int? ?? 0,
            totalTokens: context.metadata['totalTokens'] as int? ?? 0,
          );
          await lifecycle.onConversationEnd!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onCompaction != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:compaction',
        type: HookType.onCompaction,
        priority: HookPriority.normal,
        name: 'Compaction Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = CompactionEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            messagesBefore: context.metadata['messagesBefore'] as int? ?? 0,
            messagesAfter: context.metadata['messagesAfter'] as int? ?? 0,
            tokensBefore: context.metadata['tokensBefore'] as int? ?? 0,
            tokensAfter: context.metadata['tokensAfter'] as int? ?? 0,
          );
          await lifecycle.onCompaction!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }
}