registerAgent method

void registerAgent(AgentLifecycle lifecycle)

Register agent lifecycle callbacks.

Implementation

void registerAgent(AgentLifecycle lifecycle) {
  if (lifecycle.onAgentSpawned != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:agent:spawned',
        type: HookType.onAgentSpawn,
        priority: HookPriority.normal,
        name: 'Agent Spawned Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = AgentSpawnedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            agentId: context.metadata['agentId'] as String? ?? '',
            task: context.metadata['task'] as String? ?? '',
            parentId: context.metadata['parentId'] as String?,
          );
          await lifecycle.onAgentSpawned!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onAgentMessage != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:agent:message',
        type: HookType.onFork, // Reuse fork hook for agent messages
        priority: HookPriority.normal,
        name: 'Agent Message Lifecycle',
        source: 'lifecycle',
        matcher: (context) => context.metadata['eventType'] == 'agentMessage',
        asyncHandler: (context) async {
          final event = AgentMessageEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            agentId: context.metadata['agentId'] as String? ?? '',
            message: context.metadata['message'] as String? ?? '',
            messageType:
                context.metadata['messageType'] as String? ?? 'progress',
          );
          await lifecycle.onAgentMessage!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onAgentCompleted != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:agent:completed',
        type: HookType.onAgentComplete,
        priority: HookPriority.normal,
        name: 'Agent Completed Lifecycle',
        source: 'lifecycle',
        asyncHandler: (context) async {
          final event = AgentCompletedEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            agentId: context.metadata['agentId'] as String? ?? '',
            result: context.metadata['result'] as String? ?? '',
            duration:
                context.metadata['duration'] as Duration? ?? Duration.zero,
            tokensUsed: context.metadata['tokensUsed'] as int? ?? 0,
          );
          await lifecycle.onAgentCompleted!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onAgentError != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:agent:error',
        type: HookType.onError,
        priority: HookPriority.normal,
        name: 'Agent Error Lifecycle',
        source: 'lifecycle',
        matcher: (context) =>
            context is ErrorHookContext && context.source == 'agent',
        asyncHandler: (context) async {
          if (context is! ErrorHookContext) return const HookContinue();
          final event = AgentErrorEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            agentId: context.metadata['agentId'] as String? ?? '',
            error: context.error,
            stackTrace: context.stackTrace,
            recoverable: context.recoverable,
          );
          await lifecycle.onAgentError!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }

  if (lifecycle.onAgentTimeout != null) {
    _register(
      HookRegistration(
        id: 'lifecycle:agent:timeout',
        type: HookType.onError,
        priority: HookPriority.normal,
        name: 'Agent Timeout Lifecycle',
        source: 'lifecycle',
        matcher: (context) =>
            context is ErrorHookContext &&
            context.errorCategory == 'timeout' &&
            context.source == 'agent',
        asyncHandler: (context) async {
          if (context is! ErrorHookContext) return const HookContinue();
          final event = AgentTimeoutEvent(
            timestamp: context.timestamp,
            sessionId: context.sessionId,
            metadata: context.metadata,
            agentId: context.metadata['agentId'] as String? ?? '',
            timeoutDuration:
                context.metadata['timeout'] as Duration? ??
                const Duration(minutes: 5),
          );
          await lifecycle.onAgentTimeout!(event);
          _emitEvent(event);
          return const HookContinue();
        },
      ),
    );
  }
}